#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
pub mod root {
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
fn extract_bit(byte: u8, index: usize) -> bool {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
Self::extract_bit(byte, index)
}
#[inline]
pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte =
*(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize);
Self::extract_bit(byte, index)
}
#[inline]
fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
byte | mask
} else {
byte & !mask
}
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
*byte = Self::change_bit(*byte, index, val);
}
#[inline]
pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte =
(core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize);
*byte = Self::change_bit(*byte, index, val);
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!(
(bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>()
);
let mut val = 0;
for i in 0..(bit_width as usize) {
if Self::raw_get_bit(this, i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
#[inline]
pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!(
(bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>()
);
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
Self::raw_set_bit(this, index + bit_offset, val_bit_is_set);
}
}
}
#[doc = r" If Bindgen could only determine the size and alignment of a"]
#[doc = r" type, it is represented like this."]
#[derive(PartialEq, Copy, Clone, Debug, Hash)]
#[repr(C)]
pub struct __BindgenOpaqueArray<T: Copy, const N: usize>(pub [T; N]);
impl<T: Copy + Default, const N: usize> Default for __BindgenOpaqueArray<T, N> {
fn default() -> Self {
Self([<T as Default>::default(); N])
}
}
#[allow(unused_imports)]
use self::super::root;
pub mod std {
#[allow(unused_imports)]
use self::super::super::root;
pub type integral_constant_value_type<_Ty> = _Ty;
pub type integral_constant_type = u8;
pub type true_type = u8;
pub type false_type = u8;
pub type conditional_type<_Ty1> = _Ty1;
pub type conditional_t = u8;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct less {
pub _address: u8,
}
pub type less__Unnameable_first_argument<_Ty> = _Ty;
pub type less__Unnameable_second_argument<_Ty> = _Ty;
pub type less__Unnameable_result = bool;
pub mod ranges {
#[allow(unused_imports)]
use self::super::super::super::root;
}
pub type _Compare_t = ::std::os::raw::c_schar;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct strong_ordering {
pub _Value: root::std::_Compare_t,
}
unsafe extern "C" {
#[link_name = "\u{1}?less@strong_ordering@std@@2U12@B"]
pub static strong_ordering_less: root::std::strong_ordering;
}
unsafe extern "C" {
#[link_name = "\u{1}?equal@strong_ordering@std@@2U12@B"]
pub static strong_ordering_equal: root::std::strong_ordering;
}
unsafe extern "C" {
#[link_name = "\u{1}?equivalent@strong_ordering@std@@2U12@B"]
pub static strong_ordering_equivalent: root::std::strong_ordering;
}
unsafe extern "C" {
#[link_name = "\u{1}?greater@strong_ordering@std@@2U12@B"]
pub static strong_ordering_greater: root::std::strong_ordering;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of strong_ordering"][::std::mem::size_of::<strong_ordering>() - 1usize];
["Alignment of strong_ordering"][::std::mem::align_of::<strong_ordering>() - 1usize];
["Offset of field: strong_ordering::_Value"]
[::std::mem::offset_of!(strong_ordering, _Value) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct input_iterator_tag {
pub _address: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of input_iterator_tag"][::std::mem::size_of::<input_iterator_tag>() - 1usize];
["Alignment of input_iterator_tag"]
[::std::mem::align_of::<input_iterator_tag>() - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct forward_iterator_tag {
pub _address: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of forward_iterator_tag"]
[::std::mem::size_of::<forward_iterator_tag>() - 1usize];
["Alignment of forward_iterator_tag"]
[::std::mem::align_of::<forward_iterator_tag>() - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bidirectional_iterator_tag {
pub _address: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of bidirectional_iterator_tag"]
[::std::mem::size_of::<bidirectional_iterator_tag>() - 1usize];
["Alignment of bidirectional_iterator_tag"]
[::std::mem::align_of::<bidirectional_iterator_tag>() - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct random_access_iterator_tag {
pub _address: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of random_access_iterator_tag"]
[::std::mem::size_of::<random_access_iterator_tag>() - 1usize];
["Alignment of random_access_iterator_tag"]
[::std::mem::align_of::<random_access_iterator_tag>() - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct contiguous_iterator_tag {
pub _address: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of contiguous_iterator_tag"]
[::std::mem::size_of::<contiguous_iterator_tag>() - 1usize];
["Alignment of contiguous_iterator_tag"]
[::std::mem::align_of::<contiguous_iterator_tag>() - 1usize];
};
pub type iter_difference_t = root::std::conditional_t;
pub type iter_value_t = root::std::conditional_t;
pub type iter_reference_t = u8;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _Iterator_traits_base {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iterator_traits {
pub _address: u8,
}
pub type iterator_traits__From_primary = root::std::iterator_traits;
impl Default for iterator_traits {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type _Iter_ref_t = root::std::iter_reference_t;
pub type _Iter_value_t = root::std::iter_value_t;
pub type _Iter_diff_t = root::std::iter_difference_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct reverse_iterator<_BidIt> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_BidIt>>,
pub current: _BidIt,
}
pub type reverse_iterator_iterator_type<_BidIt> = _BidIt;
pub type reverse_iterator_iterator_concept = root::std::conditional_t;
pub type reverse_iterator_iterator_category = root::std::conditional_t;
pub type reverse_iterator_value_type = root::std::_Iter_value_t;
pub type reverse_iterator_difference_type = root::std::_Iter_diff_t;
pub type reverse_iterator_pointer = root::std::iterator_traits;
pub type reverse_iterator_reference = root::std::_Iter_ref_t;
pub type reverse_iterator__Prevent_inheriting_unwrap<_BidIt> =
root::std::reverse_iterator<_BidIt>;
impl<_BidIt> Default for reverse_iterator<_BidIt> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct allocator {
pub _address: u8,
}
pub type allocator__From_primary = root::std::allocator;
pub type allocator_value_type<_Ty> = _Ty;
pub type allocator_size_type = ::std::os::raw::c_ulonglong;
pub type allocator_difference_type = ::std::os::raw::c_longlong;
pub type allocator_propagate_on_container_move_assignment = root::std::true_type;
pub type allocator_is_always_equal = root::std::true_type;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vector {
pub _address: u8,
}
pub type vector__Alty = u8;
pub type vector__Alty_traits = u8;
pub type vector_value_type = u8;
pub type vector_allocator_type = u8;
pub type vector_pointer = u8;
pub type vector_const_pointer = u8;
pub type vector_reference = u8;
pub type vector_const_reference = u8;
pub type vector_size_type = u8;
pub type vector_difference_type = u8;
pub type vector__Scary_val = u8;
pub type vector_iterator = u8;
pub type vector_const_iterator = u8;
pub type vector_reverse_iterator = u8;
pub type vector_const_reverse_iterator = u8;
pub mod vector__Reallocation_policy {
pub type Type = ::std::os::raw::c_int;
pub const _At_least: Type = 0;
pub const _Exactly: Type = 0;
}
pub type streamoff = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fpos<_Statetype> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Statetype>>,
pub _Myoff: root::std::streamoff,
pub _Fpos: ::std::os::raw::c_longlong,
pub _Mystate: _Statetype,
}
impl<_Statetype> Default for fpos<_Statetype> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type streampos = root::std::fpos<root::_Mbstatet>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _Char_traits {
pub _address: u8,
}
pub type _Char_traits_char_type<_Elem> = _Elem;
pub type _Char_traits_int_type<_Int_type> = _Int_type;
pub type _Char_traits_pos_type = root::std::streampos;
pub type _Char_traits_off_type = root::std::streamoff;
pub type _Char_traits_state_type = root::_Mbstatet;
pub type _Char_traits_comparison_category = root::std::strong_ordering;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct char_traits {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _String_view_iterator {
pub _Myptr: root::std::_String_view_iterator_pointer,
}
pub type _String_view_iterator_iterator_concept = root::std::contiguous_iterator_tag;
pub type _String_view_iterator_iterator_category = root::std::random_access_iterator_tag;
pub type _String_view_iterator_value_type = root::__BindgenOpaqueArray<u8, 0usize>;
pub type _String_view_iterator_difference_type = ::std::os::raw::c_longlong;
pub type _String_view_iterator_pointer = *const root::std::_String_view_iterator_value_type;
pub type _String_view_iterator_reference =
*const root::std::_String_view_iterator_value_type;
pub type _String_view_iterator__Prevent_inheriting_unwrap =
root::std::_String_view_iterator;
impl Default for _String_view_iterator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct basic_string_view<_Elem> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Elem>>,
pub _Mydata: root::std::basic_string_view_const_pointer<_Elem>,
pub _Mysize: root::std::basic_string_view_size_type,
}
pub type basic_string_view_traits_type<_Traits> = _Traits;
pub type basic_string_view_value_type<_Elem> = _Elem;
pub type basic_string_view_pointer<_Elem> = *mut _Elem;
pub type basic_string_view_const_pointer<_Elem> = *const _Elem;
pub type basic_string_view_reference<_Elem> = *mut _Elem;
pub type basic_string_view_const_reference<_Elem> = *const _Elem;
pub type basic_string_view_const_iterator = root::std::_String_view_iterator;
pub type basic_string_view_iterator = root::std::basic_string_view_const_iterator;
pub type basic_string_view_const_reverse_iterator =
root::std::reverse_iterator<root::std::basic_string_view_const_iterator>;
pub type basic_string_view_reverse_iterator =
root::std::basic_string_view_const_reverse_iterator;
pub type basic_string_view_size_type = ::std::os::raw::c_ulonglong;
pub type basic_string_view_difference_type = ::std::os::raw::c_longlong;
impl<_Elem> Default for basic_string_view<_Elem> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type string_view = root::__BindgenOpaqueArray<u64, 2usize>;
pub type wstring_view = root::std::basic_string_view<u16>;
pub type string = root::__BindgenOpaqueArray<u64, 4usize>;
pub mod filesystem {
#[allow(unused_imports)]
use self::super::super::super::root;
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct path {
pub _bindgen_opaque_blob: [u64; 4usize],
}
pub type path_value_type = u16;
pub type path_string_type = root::__BindgenOpaqueArray<u64, 4usize>;
pub mod path_format {
pub type Type = ::std::os::raw::c_int;
pub const auto_format: Type = 0;
pub const native_format: Type = 1;
pub const generic_format: Type = 2;
}
pub type path_iterator = root::__BindgenOpaqueArray<u64, 6usize>;
pub type path_const_iterator = root::__BindgenOpaqueArray<u64, 6usize>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of path"][::std::mem::size_of::<path>() - 32usize];
["Alignment of path"][::std::mem::align_of::<path>() - 8usize];
};
pub const path_preferred_separator: u16 = 92;
}
pub type _Array_const_iterator_iterator_concept = root::std::contiguous_iterator_tag;
pub type _Array_const_iterator_iterator_category = root::std::random_access_iterator_tag;
pub type _Array_const_iterator_value_type<_Ty> = _Ty;
pub type _Array_const_iterator_difference_type = ::std::os::raw::c_longlong;
pub type _Array_const_iterator_pointer<_Ty> = *const _Ty;
pub type _Array_const_iterator_reference<_Ty> = *const _Ty;
pub mod _Array_const_iterator__bindgen_ty_1 {
pub type Type = ::std::os::raw::c_int;
pub const _EEN_SIZE: Type = 0;
}
pub type _Array_const_iterator__Prevent_inheriting_unwrap = u8;
pub type _Array_iterator__Mybase = u8;
pub type _Array_iterator_iterator_concept = root::std::contiguous_iterator_tag;
pub type _Array_iterator_iterator_category = root::std::random_access_iterator_tag;
pub type _Array_iterator_value_type<_Ty> = _Ty;
pub type _Array_iterator_difference_type = ::std::os::raw::c_longlong;
pub type _Array_iterator_pointer<_Ty> = *mut _Ty;
pub type _Array_iterator_reference<_Ty> = *mut _Ty;
pub mod _Array_iterator__bindgen_ty_1 {
pub type Type = ::std::os::raw::c_int;
pub const _EEN_SIZE: Type = 0;
}
pub type _Array_iterator__Prevent_inheriting_unwrap = u8;
pub type array_value_type<_Ty> = _Ty;
pub type array_size_type = ::std::os::raw::c_ulonglong;
pub type array_difference_type = ::std::os::raw::c_longlong;
pub type array_pointer<_Ty> = *mut _Ty;
pub type array_const_pointer<_Ty> = *const _Ty;
pub type array_reference<_Ty> = *mut _Ty;
pub type array_const_reference<_Ty> = *const _Ty;
pub type array_iterator = u8;
pub type array_const_iterator = u8;
pub type array_reverse_iterator = root::std::reverse_iterator<root::std::array_iterator>;
pub type array_const_reverse_iterator =
root::std::reverse_iterator<root::std::array_const_iterator>;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _Mbstatet {
pub _Wchar: ::std::os::raw::c_ulong,
pub _Byte: ::std::os::raw::c_ushort,
pub _State: ::std::os::raw::c_ushort,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _Mbstatet"][::std::mem::size_of::<_Mbstatet>() - 8usize];
["Alignment of _Mbstatet"][::std::mem::align_of::<_Mbstatet>() - 4usize];
["Offset of field: _Mbstatet::_Wchar"][::std::mem::offset_of!(_Mbstatet, _Wchar) - 0usize];
["Offset of field: _Mbstatet::_Byte"][::std::mem::offset_of!(_Mbstatet, _Byte) - 4usize];
["Offset of field: _Mbstatet::_State"][::std::mem::offset_of!(_Mbstatet, _State) - 6usize];
};
pub mod RED4ext {
#[allow(unused_imports)]
use self::super::super::root;
pub mod Detail {
#[allow(unused_imports)]
use self::super::super::super::root;
pub mod AddressHashes {
#[allow(unused_imports)]
use self::super::super::super::super::root;
pub const CBaseFunction_Handlers: ::std::os::raw::c_uint = 1518151849;
pub const CBaseFunction_ExecuteScripted: ::std::os::raw::c_uint = 3791200470;
pub const CBaseFunction_ExecuteNative: ::std::os::raw::c_uint = 3778157291;
pub const CBaseFunction_InternalExecute: ::std::os::raw::c_uint = 404169501;
pub const CBaseRTTIType_sub_80: ::std::os::raw::c_uint = 3832485534;
pub const CBaseRTTIType_sub_88: ::std::os::raw::c_uint = 364779332;
pub const CBaseRTTIType_sub_90: ::std::os::raw::c_uint = 2757309857;
pub const CBaseRTTIType_sub_98: ::std::os::raw::c_uint = 2930319133;
pub const CBaseRTTIType_sub_A0: ::std::os::raw::c_uint = 2396396482;
pub const CBitfield_Unserialize: ::std::os::raw::c_uint = 2794985748;
pub const CBitfield_ToString: ::std::os::raw::c_uint = 1411585028;
pub const CBitfield_FromString: ::std::os::raw::c_uint = 2694518184;
pub const CClass_Unserialize: ::std::os::raw::c_uint = 3836349613;
pub const CClass_ToString: ::std::os::raw::c_uint = 1697201926;
pub const CClass_sub_80: ::std::os::raw::c_uint = 298916620;
pub const CClass_sub_88: ::std::os::raw::c_uint = 1272912818;
pub const CClass_sub_90: ::std::os::raw::c_uint = 2725066574;
pub const CClass_sub_98: ::std::os::raw::c_uint = 1220550858;
pub const CClass_sub_A0: ::std::os::raw::c_uint = 368188783;
pub const CClass_sub_B0: ::std::os::raw::c_uint = 2693863796;
pub const CClass_sub_C0: ::std::os::raw::c_uint = 3523744305;
pub const CClass_GetMaxAlignment: ::std::os::raw::c_uint = 3511554608;
pub const CClass_sub_D0: ::std::os::raw::c_uint = 930418367;
pub const CClass_CreateInstance: ::std::os::raw::c_uint = 1518341917;
pub const CClass_GetProperty: ::std::os::raw::c_uint = 2399343890;
pub const CClass_GetProperties: ::std::os::raw::c_uint = 1652956141;
pub const CClass_ClearScriptedData: ::std::os::raw::c_uint = 837947027;
pub const CClass_InitializeProperties: ::std::os::raw::c_uint = 2257327441;
pub const CClass_AssignDefaultValuesToProperties: ::std::os::raw::c_uint =
2547979664;
pub const CClassFunction_ctor: ::std::os::raw::c_uint = 1613572595;
pub const CClassStaticFunction_ctor: ::std::os::raw::c_uint = 2920426135;
pub const CEnum_Unserialize: ::std::os::raw::c_uint = 1087575974;
pub const CEnum_ToString: ::std::os::raw::c_uint = 68817558;
pub const CEnum_FromString: ::std::os::raw::c_uint = 566894273;
pub const CGameEngine: ::std::os::raw::c_uint = 2549221846;
pub const CGlobalFunction_ctor: ::std::os::raw::c_uint = 4201325776;
pub const CNamePool_AddCstr: ::std::os::raw::c_uint = 10488987;
pub const CNamePool_AddCString: ::std::os::raw::c_uint = 4292220681;
pub const CNamePool_AddPair: ::std::os::raw::c_uint = 3649309656;
pub const CNamePool_Get: ::std::os::raw::c_uint = 1759447004;
pub const GetFreeCommandList: ::std::os::raw::c_uint = 1926836641;
pub const CommandListContext_dtor: ::std::os::raw::c_uint = 4228123904;
pub const CommandListContext_AddPendingBarrier: ::std::os::raw::c_uint = 2814122829;
pub const CommandListContext_Close: ::std::os::raw::c_uint = 1163138096;
pub const CommandListContext_FlushPendingBarriers: ::std::os::raw::c_uint =
2786924000;
pub const CRTTIRegistrator_RTTIAsyncId: ::std::os::raw::c_uint = 3720157672;
pub const CRTTIScriptReferenceType_ctor: ::std::os::raw::c_uint = 3414823260;
pub const CRTTIScriptReferenceType_Set: ::std::os::raw::c_uint = 586028847;
pub const CRTTISystem_Get: ::std::os::raw::c_uint = 1247874916;
pub const CStack_vtbl: ::std::os::raw::c_uint = 882511585;
pub const CString_ctor_str: ::std::os::raw::c_uint = 3357477547;
pub const CString_ctor_span: ::std::os::raw::c_uint = 2065762423;
pub const CString_copy: ::std::os::raw::c_uint = 3904113489;
pub const CString_dtor: ::std::os::raw::c_uint = 1409615660;
pub const g_DeviceData: ::std::os::raw::c_uint = 1239944840;
pub const DynArray_Realloc: ::std::os::raw::c_uint = 2057311186;
pub const Allocator_CreateResource: ::std::os::raw::c_uint = 2508272872;
pub const Handle_ctor: ::std::os::raw::c_uint = 3121353053;
pub const Handle_DecWeakRef: ::std::os::raw::c_uint = 859509764;
pub const IRenderProxy_sub_00: ::std::os::raw::c_uint = 302583262;
pub const IRenderProxy_sub_08: ::std::os::raw::c_uint = 3505328647;
pub const IRenderProxy_sub_18: ::std::os::raw::c_uint = 2756580845;
pub const IRenderProxy_sub_58: ::std::os::raw::c_uint = 2462126272;
pub const IRenderProxy_sub_60: ::std::os::raw::c_uint = 3491501770;
pub const IRenderProxy_sub_78: ::std::os::raw::c_uint = 2542474580;
pub const IRenderProxy_sub_80: ::std::os::raw::c_uint = 510274732;
pub const IRenderProxy_sub_88: ::std::os::raw::c_uint = 3724941976;
pub const IRenderProxy_sub_90: ::std::os::raw::c_uint = 1894391003;
pub const IRenderProxy_sub_98: ::std::os::raw::c_uint = 3516862860;
pub const IRenderProxy_sub_A8: ::std::os::raw::c_uint = 4096926792;
pub const IRenderProxy_sub_B0: ::std::os::raw::c_uint = 1468405902;
pub const IScriptable_sub_D8: ::std::os::raw::c_uint = 4175699423;
pub const IScriptable_DestructValueHolder: ::std::os::raw::c_uint = 55710513;
pub const ISerializable_sub_30: ::std::os::raw::c_uint = 114701897;
pub const ISerializable_sub_40: ::std::os::raw::c_uint = 2293436409;
pub const ISerializable_sub_78: ::std::os::raw::c_uint = 2715367827;
pub const ISerializable_sub_A0: ::std::os::raw::c_uint = 3978435378;
pub const ISerializable_sub_C0: ::std::os::raw::c_uint = 2149588021;
pub const ISerializable_Counter: ::std::os::raw::c_uint = 2630817091;
pub const JobDispatcher: ::std::os::raw::c_uint = 1508445968;
pub const JobDispatcher_DispatchJob: ::std::os::raw::c_uint = 2621709954;
pub const JobHandle_dtor: ::std::os::raw::c_uint = 2655521326;
pub const JobHandle_Join: ::std::os::raw::c_uint = 2627471740;
pub const JobInternalHandle_Acquire: ::std::os::raw::c_uint = 1862212562;
pub const JobQueue_ctor_FromGroup: ::std::os::raw::c_uint = 242552139;
pub const JobQueue_ctor_FromParams: ::std::os::raw::c_uint = 2193429752;
pub const JobQueue_dtor: ::std::os::raw::c_uint = 1525942140;
pub const JobQueue_Capture: ::std::os::raw::c_uint = 69014212;
pub const JobQueue_SyncWait: ::std::os::raw::c_uint = 3651996672;
pub const Memory_Vault: ::std::os::raw::c_uint = 458427884;
pub const Memory_Vault_Alloc: ::std::os::raw::c_uint = 2418676960;
pub const Memory_Vault_AllocAligned: ::std::os::raw::c_uint = 1365841885;
pub const Memory_Vault_Realloc: ::std::os::raw::c_uint = 1997150124;
pub const Memory_Vault_ReallocAligned: ::std::os::raw::c_uint = 1452677801;
pub const Memory_Vault_Free: ::std::os::raw::c_uint = 859968306;
pub const Memory_Vault_Unk1: ::std::os::raw::c_uint = 434901863;
pub const Memory_PoolStorage_OOM: ::std::os::raw::c_uint = 3578730042;
pub const OpcodeHandlers: ::std::os::raw::c_uint = 961751128;
pub const ObjectPackageExtractor_Initialize: ::std::os::raw::c_uint = 2318998714;
pub const ObjectPackageExtractor_ExtractSync: ::std::os::raw::c_uint = 2038372664;
pub const ObjectPackageExtractor_ExtractAsync: ::std::os::raw::c_uint = 3819248393;
pub const ObjectPackageReader_ctor: ::std::os::raw::c_uint = 3628731410;
pub const ObjectPackageReader_OnReadHeader: ::std::os::raw::c_uint = 1632836642;
pub const ObjectPackageReader_ReadHeader: ::std::os::raw::c_uint = 1285757088;
pub const BasePackageReader_ReadHeader: ::std::os::raw::c_uint = 3410956665;
pub const ResourceDepot: ::std::os::raw::c_uint = 1704595399;
pub const ResourceLoader: ::std::os::raw::c_uint = 2017202228;
pub const ResourceLoader_FindTokenFast: ::std::os::raw::c_uint = 3362732471;
pub const ResourceLoader_IssueLoadingRequest: ::std::os::raw::c_uint = 2365013187;
pub const ResourceLoader_IssueLoadingRequestByPath: ::std::os::raw::c_uint =
1250309504;
pub const ResourceReference_Load: ::std::os::raw::c_uint = 15404457;
pub const ResourceReference_Fetch: ::std::os::raw::c_uint = 3063747982;
pub const ResourceReference_Reset: ::std::os::raw::c_uint = 587736171;
pub const ResourceToken_dtor: ::std::os::raw::c_uint = 2589919757;
pub const ResourceToken_Fetch: ::std::os::raw::c_uint = 2349406410;
pub const ResourceToken_OnLoaded: ::std::os::raw::c_uint = 3947570603;
pub const ResourceToken_CancelUnk38: ::std::os::raw::c_uint = 4142009574;
pub const ResourceToken_DestructUnk38: ::std::os::raw::c_uint = 2508398574;
pub const TTypedClass_IsEqual: ::std::os::raw::c_uint = 1482886888;
pub const TweakDB_Get: ::std::os::raw::c_uint = 914361828;
pub const TweakDB_CreateRecord: ::std::os::raw::c_uint = 838931066;
pub const UpdateRegistrar_RegisterGroupUpdate: ::std::os::raw::c_uint = 4254156293;
pub const UpdateRegistrar_RegisterBucketUpdate: ::std::os::raw::c_uint = 422530722;
pub const DeferredDataBuffer_LoadAsync: ::std::os::raw::c_uint = 4125893577;
pub const DeferredDataBuffer_LoadRefAsync: ::std::os::raw::c_uint = 1459046115;
pub const LaunchParameters: ::std::os::raw::c_uint = 677908004;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct AddressResolverOverride {
pub _base: root::std::false_type,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct AllocatorHook {
pub _base: root::std::false_type,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ConstructorHook {
pub _base: root::std::false_type,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct AfterConstructedHook {
pub _base: root::std::false_type,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct BeforeDestructedHook {
pub _base: root::std::false_type,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct StaticAllocatorTypeResolver {
pub _base: root::std::false_type,
}
pub type ResolveAllocatorType = root::RED4ext::Detail::StaticAllocatorTypeResolver;
pub type UnboundFunctionPtr<R, Args> =
::std::option::Option<unsafe extern "C" fn(arg1: Args) -> R>;
pub type MemberFunctionPtr<R, Args> =
::std::option::Option<unsafe extern "C" fn(arg1: Args) -> R>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UnboundFunctionTarget<R, Args> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<R>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<Args>>,
pub func: root::RED4ext::Detail::UnboundFunctionTarget_TargetFunc<R, Args>,
}
pub type UnboundFunctionTarget_TargetFunc<R, Args> =
root::RED4ext::Detail::UnboundFunctionPtr<R, Args>;
impl<R, Args> Default for UnboundFunctionTarget<R, Args> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MemberFunctionTarget<C, R, Args> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<C>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<R>>,
pub _phantom_2: ::std::marker::PhantomData<::std::cell::UnsafeCell<Args>>,
pub context: root::RED4ext::Detail::MemberFunctionTarget_ContextPtr<C>,
pub func: root::RED4ext::Detail::MemberFunctionTarget_TargetFunc<R, Args>,
}
pub type MemberFunctionTarget_TargetFunc<R, Args> =
root::RED4ext::Detail::MemberFunctionPtr<R, Args>;
pub type MemberFunctionTarget_ContextPtr<C> = *mut C;
impl<C, R, Args> Default for MemberFunctionTarget<C, R, Args> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ClosureTarget<L> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<L>>,
pub _base: L,
}
pub type ClosureTarget_ClosureType<L> = L;
impl<L> Default for ClosureTarget<L> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SharedSpinLock {
pub state: ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of SharedSpinLock"][::std::mem::size_of::<SharedSpinLock>() - 1usize];
["Alignment of SharedSpinLock"][::std::mem::align_of::<SharedSpinLock>() - 1usize];
["Offset of field: SharedSpinLock::state"]
[::std::mem::offset_of!(SharedSpinLock, state) - 0usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?TryLock@SharedSpinLock@RED4ext@@QEAA_NXZ"]
pub fn SharedSpinLock_TryLock(this: *mut root::RED4ext::SharedSpinLock) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?Lock@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_Lock(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}?Unlock@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_Unlock(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}?TryLockShared@SharedSpinLock@RED4ext@@QEAA_NXZ"]
pub fn SharedSpinLock_TryLockShared(this: *mut root::RED4ext::SharedSpinLock) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?LockShared@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_LockShared(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}?UnlockShared@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_UnlockShared(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}?try_lock@SharedSpinLock@RED4ext@@QEAA_NXZ"]
pub fn SharedSpinLock_try_lock(this: *mut root::RED4ext::SharedSpinLock) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?lock@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_lock(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}?unlock@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_unlock(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}?try_lock_shared@SharedSpinLock@RED4ext@@QEAA_NXZ"]
pub fn SharedSpinLock_try_lock_shared(this: *mut root::RED4ext::SharedSpinLock)
-> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?lock_shared@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_lock_shared(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}?unlock_shared@SharedSpinLock@RED4ext@@QEAAXXZ"]
pub fn SharedSpinLock_unlock_shared(this: *mut root::RED4ext::SharedSpinLock);
}
unsafe extern "C" {
#[link_name = "\u{1}??0SharedSpinLock@RED4ext@@QEAA@XZ"]
pub fn SharedSpinLock_SharedSpinLock(this: *mut root::RED4ext::SharedSpinLock);
}
impl SharedSpinLock {
#[inline]
pub unsafe fn TryLock(&mut self) -> bool {
SharedSpinLock_TryLock(self)
}
#[inline]
pub unsafe fn Lock(&mut self) {
SharedSpinLock_Lock(self)
}
#[inline]
pub unsafe fn Unlock(&mut self) {
SharedSpinLock_Unlock(self)
}
#[inline]
pub unsafe fn TryLockShared(&mut self) -> bool {
SharedSpinLock_TryLockShared(self)
}
#[inline]
pub unsafe fn LockShared(&mut self) {
SharedSpinLock_LockShared(self)
}
#[inline]
pub unsafe fn UnlockShared(&mut self) {
SharedSpinLock_UnlockShared(self)
}
#[inline]
pub unsafe fn try_lock(&mut self) -> bool {
SharedSpinLock_try_lock(self)
}
#[inline]
pub unsafe fn lock(&mut self) {
SharedSpinLock_lock(self)
}
#[inline]
pub unsafe fn unlock(&mut self) {
SharedSpinLock_unlock(self)
}
#[inline]
pub unsafe fn try_lock_shared(&mut self) -> bool {
SharedSpinLock_try_lock_shared(self)
}
#[inline]
pub unsafe fn lock_shared(&mut self) {
SharedSpinLock_lock_shared(self)
}
#[inline]
pub unsafe fn unlock_shared(&mut self) {
SharedSpinLock_unlock_shared(self)
}
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
SharedSpinLock_SharedSpinLock(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
pub mod Memory {
#[allow(unused_imports)]
use self::super::super::super::root;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PoolStorage {
pub allocatorStorage: u64,
pub bytesAllocated: u64,
pub maxBytesAllocated: u64,
pub oomHandler: *mut ::std::os::raw::c_void,
pub allocatorhandle: u32,
pub allocatorId: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PoolStorage"][::std::mem::size_of::<PoolStorage>() - 40usize];
["Alignment of PoolStorage"][::std::mem::align_of::<PoolStorage>() - 8usize];
["Offset of field: PoolStorage::allocatorStorage"]
[::std::mem::offset_of!(PoolStorage, allocatorStorage) - 0usize];
["Offset of field: PoolStorage::bytesAllocated"]
[::std::mem::offset_of!(PoolStorage, bytesAllocated) - 8usize];
["Offset of field: PoolStorage::maxBytesAllocated"]
[::std::mem::offset_of!(PoolStorage, maxBytesAllocated) - 16usize];
["Offset of field: PoolStorage::oomHandler"]
[::std::mem::offset_of!(PoolStorage, oomHandler) - 24usize];
["Offset of field: PoolStorage::allocatorhandle"]
[::std::mem::offset_of!(PoolStorage, allocatorhandle) - 32usize];
["Offset of field: PoolStorage::allocatorId"]
[::std::mem::offset_of!(PoolStorage, allocatorId) - 36usize];
};
impl Default for PoolStorage {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PoolInfo {
pub budget: u64,
pub childrenBudget: u64,
pub storage: *mut root::RED4ext::Memory::PoolStorage,
pub child: *mut root::RED4ext::Memory::PoolInfo,
pub sibling: *mut root::RED4ext::Memory::PoolInfo,
pub name: [::std::os::raw::c_char; 32usize],
pub handle: u32,
pub contributeToParentMetrics: bool,
pub isMirrored: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PoolInfo"][::std::mem::size_of::<PoolInfo>() - 80usize];
["Alignment of PoolInfo"][::std::mem::align_of::<PoolInfo>() - 8usize];
["Offset of field: PoolInfo::budget"]
[::std::mem::offset_of!(PoolInfo, budget) - 0usize];
["Offset of field: PoolInfo::childrenBudget"]
[::std::mem::offset_of!(PoolInfo, childrenBudget) - 8usize];
["Offset of field: PoolInfo::storage"]
[::std::mem::offset_of!(PoolInfo, storage) - 16usize];
["Offset of field: PoolInfo::child"]
[::std::mem::offset_of!(PoolInfo, child) - 24usize];
["Offset of field: PoolInfo::sibling"]
[::std::mem::offset_of!(PoolInfo, sibling) - 32usize];
["Offset of field: PoolInfo::name"]
[::std::mem::offset_of!(PoolInfo, name) - 40usize];
["Offset of field: PoolInfo::handle"]
[::std::mem::offset_of!(PoolInfo, handle) - 72usize];
["Offset of field: PoolInfo::contributeToParentMetrics"]
[::std::mem::offset_of!(PoolInfo, contributeToParentMetrics) - 76usize];
["Offset of field: PoolInfo::isMirrored"]
[::std::mem::offset_of!(PoolInfo, isMirrored) - 77usize];
};
impl Default for PoolInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PoolRegistry {
pub nodesLock: root::RED4ext::SharedSpinLock,
pub nodes: [root::RED4ext::Memory::PoolInfo; 768usize],
}
pub const PoolRegistry_MaxPoolCount: ::std::os::raw::c_int = 768;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PoolRegistry"][::std::mem::size_of::<PoolRegistry>() - 61448usize];
["Alignment of PoolRegistry"][::std::mem::align_of::<PoolRegistry>() - 8usize];
["Offset of field: PoolRegistry::nodesLock"]
[::std::mem::offset_of!(PoolRegistry, nodesLock) - 0usize];
["Offset of field: PoolRegistry::nodes"]
[::std::mem::offset_of!(PoolRegistry, nodes) - 8usize];
};
impl Default for PoolRegistry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Vault {
pub unk0: [i8; 53632usize],
pub poolRegistry: root::RED4ext::Memory::PoolRegistry,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Vault"][::std::mem::size_of::<Vault>() - 115080usize];
["Alignment of Vault"][::std::mem::align_of::<Vault>() - 8usize];
["Offset of field: Vault::unk0"][::std::mem::offset_of!(Vault, unk0) - 0usize];
["Offset of field: Vault::poolRegistry"]
[::std::mem::offset_of!(Vault, poolRegistry) - 53632usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Get@Vault@Memory@RED4ext@@SAPEAU123@XZ"]
pub fn Vault_Get() -> *mut root::RED4ext::Memory::Vault;
}
impl Default for Vault {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Vault {
#[inline]
pub unsafe fn Get() -> *mut root::RED4ext::Memory::Vault {
Vault_Get()
}
}
#[repr(C)]
#[derive(Debug)]
pub struct TPoolInfo {
pub _base: root::RED4ext::Memory::PoolInfo,
}
impl Default for TPoolInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct PoolEngine {
pub _base: root::RED4ext::Memory::TPoolInfo,
}
pub const PoolEngine_Name: &[u8; 11] = b"PoolEngine\0";
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PoolEngine"][::std::mem::size_of::<PoolEngine>() - 80usize];
["Alignment of PoolEngine"][::std::mem::align_of::<PoolEngine>() - 8usize];
};
impl Default for PoolEngine {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct PoolRefCount {
pub _base: root::RED4ext::Memory::TPoolInfo,
}
pub const PoolRefCount_Name: &[u8; 13] = b"PoolRefCount\0";
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PoolRefCount"][::std::mem::size_of::<PoolRefCount>() - 80usize];
["Alignment of PoolRefCount"][::std::mem::align_of::<PoolRefCount>() - 8usize];
};
impl Default for PoolRefCount {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct PoolJobs2Data {
pub _base: root::RED4ext::Memory::TPoolInfo,
}
pub const PoolJobs2Data_Name: &[u8; 14] = b"PoolJobs2Data\0";
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PoolJobs2Data"][::std::mem::size_of::<PoolJobs2Data>() - 80usize];
["Alignment of PoolJobs2Data"][::std::mem::align_of::<PoolJobs2Data>() - 8usize];
};
impl Default for PoolJobs2Data {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AllocationResult {
pub memory: *mut ::std::os::raw::c_void,
pub size: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AllocationResult"][::std::mem::size_of::<AllocationResult>() - 16usize];
["Alignment of AllocationResult"]
[::std::mem::align_of::<AllocationResult>() - 8usize];
["Offset of field: AllocationResult::memory"]
[::std::mem::offset_of!(AllocationResult, memory) - 0usize];
["Offset of field: AllocationResult::size"]
[::std::mem::offset_of!(AllocationResult, size) - 8usize];
};
impl Default for AllocationResult {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
pub struct IAllocator__bindgen_vtable {
pub IAllocator_Alloc:
unsafe extern "C" fn(
this: *const IAllocator,
aSize: u32,
)
-> root::RED4ext::Memory::AllocationResult,
pub IAllocator_AllocAligned:
unsafe extern "C" fn(
this: *const IAllocator,
aSize: u32,
aAlignment: u32,
)
-> root::RED4ext::Memory::AllocationResult,
pub IAllocator_Realloc:
unsafe extern "C" fn(
this: *const IAllocator,
aAllocation: *mut root::RED4ext::Memory::AllocationResult,
aSize: u32,
)
-> root::RED4ext::Memory::AllocationResult,
pub IAllocator_ReallocAligned:
unsafe extern "C" fn(
this: *const IAllocator,
aAllocation: *mut root::RED4ext::Memory::AllocationResult,
aSize: u32,
aAlignment: u32,
)
-> root::RED4ext::Memory::AllocationResult,
pub IAllocator_Free: unsafe extern "C" fn(
this: *const IAllocator,
aAllocation: *mut root::RED4ext::Memory::AllocationResult,
),
pub IAllocator_sub_28:
unsafe extern "C" fn(this: *const IAllocator, a1: *mut ::std::os::raw::c_void),
pub IAllocator_GetHandle: unsafe extern "C" fn(this: *const IAllocator) -> u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct IAllocator {
pub vtable_: *const IAllocator__bindgen_vtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IAllocator"][::std::mem::size_of::<IAllocator>() - 8usize];
["Alignment of IAllocator"][::std::mem::align_of::<IAllocator>() - 8usize];
};
impl Default for IAllocator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Allocator {
pub _base: root::RED4ext::Memory::IAllocator,
}
impl Default for Allocator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct EngineAllocator {
pub _base: root::RED4ext::Memory::Allocator,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of EngineAllocator"][::std::mem::size_of::<EngineAllocator>() - 8usize];
["Alignment of EngineAllocator"]
[::std::mem::align_of::<EngineAllocator>() - 8usize];
};
impl Default for EngineAllocator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct RefCountAllocator {
pub _base: root::RED4ext::Memory::Allocator,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RefCountAllocator"][::std::mem::size_of::<RefCountAllocator>() - 8usize];
["Alignment of RefCountAllocator"]
[::std::mem::align_of::<RefCountAllocator>() - 8usize];
};
impl Default for RefCountAllocator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Jobs2DataAllocator {
pub _base: root::RED4ext::Memory::Allocator,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Jobs2DataAllocator"]
[::std::mem::size_of::<Jobs2DataAllocator>() - 8usize];
["Alignment of Jobs2DataAllocator"]
[::std::mem::align_of::<Jobs2DataAllocator>() - 8usize];
};
impl Default for Jobs2DataAllocator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
}
pub mod v0 {
#[allow(unused_imports)]
use self::super::super::super::root;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FileVer {
pub major: u16,
pub minor: u16,
pub build: u16,
pub revision: u16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of FileVer"][::std::mem::size_of::<FileVer>() - 8usize];
["Alignment of FileVer"][::std::mem::align_of::<FileVer>() - 2usize];
["Offset of field: FileVer::major"]
[::std::mem::offset_of!(FileVer, major) - 0usize];
["Offset of field: FileVer::minor"]
[::std::mem::offset_of!(FileVer, minor) - 2usize];
["Offset of field: FileVer::build"]
[::std::mem::offset_of!(FileVer, build) - 4usize];
["Offset of field: FileVer::revision"]
[::std::mem::offset_of!(FileVer, revision) - 6usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SemVer {
pub major: u8,
pub minor: u16,
pub patch: u32,
pub prerelease: root::RED4ext::v0::SemVer_PrereleaseInfo,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SemVer_PrereleaseInfo {
pub type_: u32,
pub number: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of SemVer_PrereleaseInfo"]
[::std::mem::size_of::<SemVer_PrereleaseInfo>() - 8usize];
["Alignment of SemVer_PrereleaseInfo"]
[::std::mem::align_of::<SemVer_PrereleaseInfo>() - 4usize];
["Offset of field: SemVer_PrereleaseInfo::type_"]
[::std::mem::offset_of!(SemVer_PrereleaseInfo, type_) - 0usize];
["Offset of field: SemVer_PrereleaseInfo::number"]
[::std::mem::offset_of!(SemVer_PrereleaseInfo, number) - 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of SemVer"][::std::mem::size_of::<SemVer>() - 16usize];
["Alignment of SemVer"][::std::mem::align_of::<SemVer>() - 4usize];
["Offset of field: SemVer::major"][::std::mem::offset_of!(SemVer, major) - 0usize];
["Offset of field: SemVer::minor"][::std::mem::offset_of!(SemVer, minor) - 2usize];
["Offset of field: SemVer::patch"][::std::mem::offset_of!(SemVer, patch) - 4usize];
["Offset of field: SemVer::prerelease"]
[::std::mem::offset_of!(SemVer, prerelease) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PluginInfo {
pub sdk: root::RED4ext::v0::SemVer,
pub name: *const u16,
pub author: *const u16,
pub version: root::RED4ext::v0::SemVer,
pub runtime: root::RED4ext::v0::FileVer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PluginInfo"][::std::mem::size_of::<PluginInfo>() - 56usize];
["Alignment of PluginInfo"][::std::mem::align_of::<PluginInfo>() - 8usize];
["Offset of field: PluginInfo::sdk"]
[::std::mem::offset_of!(PluginInfo, sdk) - 0usize];
["Offset of field: PluginInfo::name"]
[::std::mem::offset_of!(PluginInfo, name) - 16usize];
["Offset of field: PluginInfo::author"]
[::std::mem::offset_of!(PluginInfo, author) - 24usize];
["Offset of field: PluginInfo::version"]
[::std::mem::offset_of!(PluginInfo, version) - 32usize];
["Offset of field: PluginInfo::runtime"]
[::std::mem::offset_of!(PluginInfo, runtime) - 48usize];
};
impl Default for PluginInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct GameState {
pub OnEnter: ::std::option::Option<
unsafe extern "C" fn(aApp: *mut root::RED4ext::CGameApplication) -> bool,
>,
pub OnUpdate: ::std::option::Option<
unsafe extern "C" fn(aApp: *mut root::RED4ext::CGameApplication) -> bool,
>,
pub OnExit: ::std::option::Option<
unsafe extern "C" fn(aApp: *mut root::RED4ext::CGameApplication) -> bool,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of GameState"][::std::mem::size_of::<GameState>() - 24usize];
["Alignment of GameState"][::std::mem::align_of::<GameState>() - 8usize];
["Offset of field: GameState::OnEnter"]
[::std::mem::offset_of!(GameState, OnEnter) - 0usize];
["Offset of field: GameState::OnUpdate"]
[::std::mem::offset_of!(GameState, OnUpdate) - 8usize];
["Offset of field: GameState::OnExit"]
[::std::mem::offset_of!(GameState, OnExit) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct GameStates {
pub Add: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aType: root::RED4ext::EGameStateType::Type,
aState: *mut root::RED4ext::v0::GameState,
) -> bool,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of GameStates"][::std::mem::size_of::<GameStates>() - 8usize];
["Alignment of GameStates"][::std::mem::align_of::<GameStates>() - 8usize];
["Offset of field: GameStates::Add"]
[::std::mem::offset_of!(GameStates, Add) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Hooking {
pub Attach: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aTarget: *mut ::std::os::raw::c_void,
aDetour: *mut ::std::os::raw::c_void,
aOriginal: *mut *mut ::std::os::raw::c_void,
) -> bool,
>,
pub Detach: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aTarget: *mut ::std::os::raw::c_void,
) -> bool,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Hooking"][::std::mem::size_of::<Hooking>() - 16usize];
["Alignment of Hooking"][::std::mem::align_of::<Hooking>() - 8usize];
["Offset of field: Hooking::Attach"]
[::std::mem::offset_of!(Hooking, Attach) - 0usize];
["Offset of field: Hooking::Detach"]
[::std::mem::offset_of!(Hooking, Detach) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Logger {
pub Trace: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const ::std::os::raw::c_char,
),
>,
pub TraceF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const ::std::os::raw::c_char,
...
),
>,
pub TraceW: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const u16,
),
>,
pub TraceWF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const u16,
...
),
>,
pub Debug: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const ::std::os::raw::c_char,
),
>,
pub DebugF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const ::std::os::raw::c_char,
...
),
>,
pub DebugW: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const u16,
),
>,
pub DebugWF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const u16,
...
),
>,
pub Info: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const ::std::os::raw::c_char,
),
>,
pub InfoF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const ::std::os::raw::c_char,
...
),
>,
pub InfoW: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const u16,
),
>,
pub InfoWF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const u16,
...
),
>,
pub Warn: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const ::std::os::raw::c_char,
),
>,
pub WarnF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const ::std::os::raw::c_char,
...
),
>,
pub WarnW: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const u16,
),
>,
pub WarnWF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const u16,
...
),
>,
pub Error: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const ::std::os::raw::c_char,
),
>,
pub ErrorF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const ::std::os::raw::c_char,
...
),
>,
pub ErrorW: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const u16,
),
>,
pub ErrorWF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const u16,
...
),
>,
pub Critical: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const ::std::os::raw::c_char,
),
>,
pub CriticalF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const ::std::os::raw::c_char,
...
),
>,
pub CriticalW: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aMessage: *const u16,
),
>,
pub CriticalWF: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aFormat: *const u16,
...
),
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Logger"][::std::mem::size_of::<Logger>() - 192usize];
["Alignment of Logger"][::std::mem::align_of::<Logger>() - 8usize];
["Offset of field: Logger::Trace"][::std::mem::offset_of!(Logger, Trace) - 0usize];
["Offset of field: Logger::TraceF"]
[::std::mem::offset_of!(Logger, TraceF) - 8usize];
["Offset of field: Logger::TraceW"]
[::std::mem::offset_of!(Logger, TraceW) - 16usize];
["Offset of field: Logger::TraceWF"]
[::std::mem::offset_of!(Logger, TraceWF) - 24usize];
["Offset of field: Logger::Debug"][::std::mem::offset_of!(Logger, Debug) - 32usize];
["Offset of field: Logger::DebugF"]
[::std::mem::offset_of!(Logger, DebugF) - 40usize];
["Offset of field: Logger::DebugW"]
[::std::mem::offset_of!(Logger, DebugW) - 48usize];
["Offset of field: Logger::DebugWF"]
[::std::mem::offset_of!(Logger, DebugWF) - 56usize];
["Offset of field: Logger::Info"][::std::mem::offset_of!(Logger, Info) - 64usize];
["Offset of field: Logger::InfoF"][::std::mem::offset_of!(Logger, InfoF) - 72usize];
["Offset of field: Logger::InfoW"][::std::mem::offset_of!(Logger, InfoW) - 80usize];
["Offset of field: Logger::InfoWF"]
[::std::mem::offset_of!(Logger, InfoWF) - 88usize];
["Offset of field: Logger::Warn"][::std::mem::offset_of!(Logger, Warn) - 96usize];
["Offset of field: Logger::WarnF"]
[::std::mem::offset_of!(Logger, WarnF) - 104usize];
["Offset of field: Logger::WarnW"]
[::std::mem::offset_of!(Logger, WarnW) - 112usize];
["Offset of field: Logger::WarnWF"]
[::std::mem::offset_of!(Logger, WarnWF) - 120usize];
["Offset of field: Logger::Error"]
[::std::mem::offset_of!(Logger, Error) - 128usize];
["Offset of field: Logger::ErrorF"]
[::std::mem::offset_of!(Logger, ErrorF) - 136usize];
["Offset of field: Logger::ErrorW"]
[::std::mem::offset_of!(Logger, ErrorW) - 144usize];
["Offset of field: Logger::ErrorWF"]
[::std::mem::offset_of!(Logger, ErrorWF) - 152usize];
["Offset of field: Logger::Critical"]
[::std::mem::offset_of!(Logger, Critical) - 160usize];
["Offset of field: Logger::CriticalF"]
[::std::mem::offset_of!(Logger, CriticalF) - 168usize];
["Offset of field: Logger::CriticalW"]
[::std::mem::offset_of!(Logger, CriticalW) - 176usize];
["Offset of field: Logger::CriticalWF"]
[::std::mem::offset_of!(Logger, CriticalWF) - 184usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Scripts {
pub Add: ::std::option::Option<
unsafe extern "C" fn(
aHandle: root::RED4ext::PluginHandle,
aPath: *const u16,
) -> bool,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Scripts"][::std::mem::size_of::<Scripts>() - 8usize];
["Alignment of Scripts"][::std::mem::align_of::<Scripts>() - 8usize];
["Offset of field: Scripts::Add"][::std::mem::offset_of!(Scripts, Add) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Sdk {
pub runtime: *mut root::RED4ext::v0::SemVer,
pub logger: *mut root::RED4ext::v0::Logger,
pub hooking: *mut root::RED4ext::v0::Hooking,
pub gameStates: *mut root::RED4ext::v0::GameStates,
pub scripts: *mut root::RED4ext::v0::Scripts,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Sdk"][::std::mem::size_of::<Sdk>() - 40usize];
["Alignment of Sdk"][::std::mem::align_of::<Sdk>() - 8usize];
["Offset of field: Sdk::runtime"][::std::mem::offset_of!(Sdk, runtime) - 0usize];
["Offset of field: Sdk::logger"][::std::mem::offset_of!(Sdk, logger) - 8usize];
["Offset of field: Sdk::hooking"][::std::mem::offset_of!(Sdk, hooking) - 16usize];
["Offset of field: Sdk::gameStates"]
[::std::mem::offset_of!(Sdk, gameStates) - 24usize];
["Offset of field: Sdk::scripts"][::std::mem::offset_of!(Sdk, scripts) - 32usize];
};
impl Default for Sdk {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
}
pub type PluginHandle = root::HMODULE;
pub type PluginInfo = root::RED4ext::v0::PluginInfo;
pub type SemVer = root::RED4ext::v0::SemVer;
pub type FileVer = root::RED4ext::v0::FileVer;
pub type Sdk = root::RED4ext::v0::Sdk;
pub type Logger = root::RED4ext::v0::Logger;
pub type Hooking = root::RED4ext::v0::Hooking;
pub type GameStates = root::RED4ext::v0::GameStates;
pub type GameState = root::RED4ext::v0::GameState;
pub type Scripts = root::RED4ext::v0::Scripts;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct RelocBase {
pub _address: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RelocBase"][::std::mem::size_of::<RelocBase>() - 1usize];
["Alignment of RelocBase"][::std::mem::align_of::<RelocBase>() - 1usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?GetImageBase@RelocBase@RED4ext@@SA_KXZ"]
pub fn RelocBase_GetImageBase() -> usize;
}
impl RelocBase {
#[inline]
pub unsafe fn GetImageBase() -> usize {
RelocBase_GetImageBase()
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RelocFunc<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub m_address: T,
}
impl<T> Default for RelocFunc<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RelocPtr<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub m_address: *mut T,
}
impl<T> Default for RelocPtr<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RelocVtbl {
pub m_address: *mut usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RelocVtbl"][::std::mem::size_of::<RelocVtbl>() - 8usize];
["Alignment of RelocVtbl"][::std::mem::align_of::<RelocVtbl>() - 8usize];
["Offset of field: RelocVtbl::m_address"]
[::std::mem::offset_of!(RelocVtbl, m_address) - 0usize];
};
impl Default for RelocVtbl {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct UniversalRelocBase {
pub _address: u8,
}
pub type UniversalRelocBase_QueryFunc_t =
::std::option::Option<unsafe extern "C" fn(arg1: *mut root::RED4ext::PluginInfo)>;
pub type UniversalRelocBase_ResolveFunc_t = ::std::option::Option<
unsafe extern "C" fn(arg1: ::std::os::raw::c_uint) -> ::std::os::raw::c_ulonglong,
>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of UniversalRelocBase"][::std::mem::size_of::<UniversalRelocBase>() - 1usize];
["Alignment of UniversalRelocBase"]
[::std::mem::align_of::<UniversalRelocBase>() - 1usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Resolve@UniversalRelocBase@RED4ext@@SA_KI@Z"]
pub fn UniversalRelocBase_Resolve(aHash: u32) -> usize;
}
impl UniversalRelocBase {
#[inline]
pub unsafe fn Resolve(aHash: u32) -> usize {
UniversalRelocBase_Resolve(aHash)
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UniversalRelocFunc<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub m_address: T,
}
impl<T> Default for UniversalRelocFunc<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UniversalRelocPtr<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub m_address: *mut T,
}
impl<T> Default for UniversalRelocPtr<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UniversalRelocVtbl {
pub m_address: *mut usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of UniversalRelocVtbl"][::std::mem::size_of::<UniversalRelocVtbl>() - 8usize];
["Alignment of UniversalRelocVtbl"]
[::std::mem::align_of::<UniversalRelocVtbl>() - 8usize];
["Offset of field: UniversalRelocVtbl::m_address"]
[::std::mem::offset_of!(UniversalRelocVtbl, m_address) - 0usize];
};
impl Default for UniversalRelocVtbl {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct HashMapHash {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug)]
pub struct HashMap<K, T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub indexTable: *mut u32,
pub size: u32,
pub capacity: u32,
pub nodeList: root::RED4ext::HashMap_NodeList<K, T>,
pub allocator: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HashMap_Node<K, T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub next: u32,
pub hashedKey: u32,
pub key: K,
pub value: T,
}
impl<K, T> Default for HashMap_Node<K, T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HashMap_NodeList<K, T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub nodes: *mut root::RED4ext::HashMap_Node<K, T>,
pub capacity: u32,
pub stride: u32,
pub nextIdx: u32,
pub size: u32,
}
impl<K, T> Default for HashMap_NodeList<K, T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl<K, T> Default for HashMap<K, T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CName {
pub hash: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CName"][::std::mem::size_of::<CName>() - 8usize];
["Alignment of CName"][::std::mem::align_of::<CName>() - 8usize];
["Offset of field: CName::hash"][::std::mem::offset_of!(CName, hash) - 0usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?ToString@CName@RED4ext@@QEBAPEBDXZ"]
pub fn CName_ToString(
this: *const root::RED4ext::CName,
) -> *const ::std::os::raw::c_char;
}
impl CName {
#[inline]
pub unsafe fn ToString(&self) -> *const ::std::os::raw::c_char {
CName_ToString(self)
}
}
#[repr(C)]
pub struct CString {
pub text: root::RED4ext::CString__bindgen_ty_1,
pub length: u32,
pub allocator: *mut root::RED4ext::Memory::IAllocator,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CString__bindgen_ty_1 {
pub inline_str: [::std::os::raw::c_char; 20usize],
pub str_: root::RED4ext::CString__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C, packed(4))]
#[derive(Debug, Copy, Clone)]
pub struct CString__bindgen_ty_1__bindgen_ty_1 {
pub ptr: *mut ::std::os::raw::c_char,
pub unk: [i8; 8usize],
pub capacity: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CString__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::size_of::<CString__bindgen_ty_1__bindgen_ty_1>() - 20usize];
["Alignment of CString__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::align_of::<CString__bindgen_ty_1__bindgen_ty_1>() - 4usize];
["Offset of field: CString__bindgen_ty_1__bindgen_ty_1::ptr"]
[::std::mem::offset_of!(CString__bindgen_ty_1__bindgen_ty_1, ptr) - 0usize];
["Offset of field: CString__bindgen_ty_1__bindgen_ty_1::unk"]
[::std::mem::offset_of!(CString__bindgen_ty_1__bindgen_ty_1, unk) - 8usize];
["Offset of field: CString__bindgen_ty_1__bindgen_ty_1::capacity"]
[::std::mem::offset_of!(CString__bindgen_ty_1__bindgen_ty_1, capacity) - 16usize];
};
impl Default for CString__bindgen_ty_1__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CString__bindgen_ty_1"]
[::std::mem::size_of::<CString__bindgen_ty_1>() - 20usize];
["Alignment of CString__bindgen_ty_1"]
[::std::mem::align_of::<CString__bindgen_ty_1>() - 4usize];
["Offset of field: CString__bindgen_ty_1::inline_str"]
[::std::mem::offset_of!(CString__bindgen_ty_1, inline_str) - 0usize];
["Offset of field: CString__bindgen_ty_1::str_"]
[::std::mem::offset_of!(CString__bindgen_ty_1, str_) - 0usize];
};
impl Default for CString__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CString"][::std::mem::size_of::<CString>() - 32usize];
["Alignment of CString"][::std::mem::align_of::<CString>() - 8usize];
["Offset of field: CString::text"][::std::mem::offset_of!(CString, text) - 0usize];
["Offset of field: CString::length"][::std::mem::offset_of!(CString, length) - 20usize];
["Offset of field: CString::allocator"]
[::std::mem::offset_of!(CString, allocator) - 24usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?IsInline@CString@RED4ext@@QEBA_NXZ"]
pub fn CString_IsInline(this: *const root::RED4ext::CString) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?c_str@CString@RED4ext@@QEBAPEBDXZ"]
pub fn CString_c_str(
this: *const root::RED4ext::CString,
) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
#[link_name = "\u{1}?Length@CString@RED4ext@@QEBAIXZ"]
pub fn CString_Length(this: *const root::RED4ext::CString) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}??0CString@RED4ext@@QEAA@PEAUIAllocator@Memory@1@@Z"]
pub fn CString_CString(
this: *mut root::RED4ext::CString,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0CString@RED4ext@@QEAA@PEBDPEAUIAllocator@Memory@1@@Z"]
pub fn CString_CString1(
this: *mut root::RED4ext::CString,
aText: *const ::std::os::raw::c_char,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0CString@RED4ext@@QEAA@PEBDIPEAUIAllocator@Memory@1@@Z"]
pub fn CString_CString2(
this: *mut root::RED4ext::CString,
aText: *const ::std::os::raw::c_char,
aLength: u32,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0CString@RED4ext@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@PEAUIAllocator@Memory@1@@Z"]
pub fn CString_CString3(
this: *mut root::RED4ext::CString,
aText: *const root::std::string,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0CString@RED4ext@@QEAA@AEBV?$basic_string_view@DU?$char_traits@D@std@@@std@@PEAUIAllocator@Memory@1@@Z"]
pub fn CString_CString4(
this: *mut root::RED4ext::CString,
aText: *const root::std::string_view,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0CString@RED4ext@@QEAA@AEBU01@@Z"]
pub fn CString_CString5(
this: *mut root::RED4ext::CString,
aOther: *const root::RED4ext::CString,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0CString@RED4ext@@QEAA@$$QEAU01@@Z"]
pub fn CString_CString6(
this: *mut root::RED4ext::CString,
aOther: *mut root::RED4ext::CString,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??1CString@RED4ext@@QEAA@XZ"]
pub fn CString_CString_destructor(this: *mut root::RED4ext::CString);
}
impl Default for CString {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CString {
#[inline]
pub unsafe fn IsInline(&self) -> bool {
CString_IsInline(self)
}
#[inline]
pub unsafe fn c_str(&self) -> *const ::std::os::raw::c_char {
CString_c_str(self)
}
#[inline]
pub unsafe fn Length(&self) -> u32 {
CString_Length(self)
}
#[inline]
pub unsafe fn new(aAllocator: *mut root::RED4ext::Memory::IAllocator) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CString_CString(__bindgen_tmp.as_mut_ptr(), aAllocator);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(
aText: *const ::std::os::raw::c_char,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CString_CString1(__bindgen_tmp.as_mut_ptr(), aText, aAllocator);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new2(
aText: *const ::std::os::raw::c_char,
aLength: u32,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CString_CString2(__bindgen_tmp.as_mut_ptr(), aText, aLength, aAllocator);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new3(
aText: *const root::std::string,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CString_CString3(__bindgen_tmp.as_mut_ptr(), aText, aAllocator);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new4(
aText: *const root::std::string_view,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CString_CString4(__bindgen_tmp.as_mut_ptr(), aText, aAllocator);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new5(aOther: *const root::RED4ext::CString) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CString_CString5(__bindgen_tmp.as_mut_ptr(), aOther);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new6(aOther: *mut root::RED4ext::CString) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CString_CString6(__bindgen_tmp.as_mut_ptr(), aOther);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
CString_CString_destructor(self)
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CNamePool {
pub _address: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CNamePool"][::std::mem::size_of::<CNamePool>() - 1usize];
["Alignment of CNamePool"][::std::mem::align_of::<CNamePool>() - 1usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Add@CNamePool@RED4ext@@SA?AUCName@2@PEBD@Z"]
pub fn CNamePool_Add(aText: *const ::std::os::raw::c_char) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?Add@CNamePool@RED4ext@@SA?AUCName@2@AEBUCString@2@@Z"]
pub fn CNamePool_Add1(aText: *const root::RED4ext::CString) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?Add@CNamePool@RED4ext@@SAXAEBUCName@2@PEBD@Z"]
pub fn CNamePool_Add2(
aName: *const root::RED4ext::CName,
aText: *const ::std::os::raw::c_char,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Add@CNamePool@RED4ext@@SAXAEBUCName@2@AEBUCString@2@@Z"]
pub fn CNamePool_Add3(
aName: *const root::RED4ext::CName,
aText: *const root::RED4ext::CString,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Get@CNamePool@RED4ext@@SAPEBDAEBUCName@2@@Z"]
pub fn CNamePool_Get(
aName: *const root::RED4ext::CName,
) -> *const ::std::os::raw::c_char;
}
impl CNamePool {
#[inline]
pub unsafe fn Add(aText: *const ::std::os::raw::c_char) -> root::RED4ext::CName {
CNamePool_Add(aText)
}
#[inline]
pub unsafe fn Add1(aText: *const root::RED4ext::CString) -> root::RED4ext::CName {
CNamePool_Add1(aText)
}
#[inline]
pub unsafe fn Add2(
aName: *const root::RED4ext::CName,
aText: *const ::std::os::raw::c_char,
) {
CNamePool_Add2(aName, aText)
}
#[inline]
pub unsafe fn Add3(
aName: *const root::RED4ext::CName,
aText: *const root::RED4ext::CString,
) {
CNamePool_Add3(aName, aText)
}
#[inline]
pub unsafe fn Get(aName: *const root::RED4ext::CName) -> *const ::std::os::raw::c_char {
CNamePool_Get(aName)
}
}
#[repr(C)]
#[derive(Debug)]
pub struct DynArray<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub entries: *mut T,
pub capacity: u32,
pub size: u32,
}
impl<T> Default for DynArray<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub mod EGameStateStatus {
pub type Type = ::std::os::raw::c_int;
pub const Uninitialized: Type = 0;
pub const Initialized: Type = 1;
pub const Ran: Type = 2;
pub const Done: Type = 3;
}
#[repr(C)]
pub struct CGameOptions {
pub interopstartingport: u16,
pub renderPreset: bool,
pub unk3: u8,
pub lowSettingsOptions: u32,
pub texQualityLevel: u32,
pub meshQualityLevel: u32,
pub watchdogTimeout: u32,
pub scriptVersion: i8,
pub scriptProfiling: i16,
pub scriptsBlobPath: root::RED4ext::CString,
pub tweakdbBlobPath: root::RED4ext::CString,
pub unattended58: u8,
pub unattended59: u8,
pub unattended5A: u8,
pub forceRawTweakDB: bool,
pub pvdDumpToFile: bool,
pub profiler: bool,
pub unk5E: u8,
pub unk5F: u8,
pub unattended60: u8,
pub unk68: i64,
pub automator: root::RED4ext::CString,
pub windowCaption: root::RED4ext::CString,
pub isBackendGameEngine: bool,
pub unkB1: u8,
pub nochroma: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CGameOptions"][::std::mem::size_of::<CGameOptions>() - 184usize];
["Alignment of CGameOptions"][::std::mem::align_of::<CGameOptions>() - 8usize];
["Offset of field: CGameOptions::interopstartingport"]
[::std::mem::offset_of!(CGameOptions, interopstartingport) - 0usize];
["Offset of field: CGameOptions::renderPreset"]
[::std::mem::offset_of!(CGameOptions, renderPreset) - 2usize];
["Offset of field: CGameOptions::unk3"]
[::std::mem::offset_of!(CGameOptions, unk3) - 3usize];
["Offset of field: CGameOptions::lowSettingsOptions"]
[::std::mem::offset_of!(CGameOptions, lowSettingsOptions) - 4usize];
["Offset of field: CGameOptions::texQualityLevel"]
[::std::mem::offset_of!(CGameOptions, texQualityLevel) - 8usize];
["Offset of field: CGameOptions::meshQualityLevel"]
[::std::mem::offset_of!(CGameOptions, meshQualityLevel) - 12usize];
["Offset of field: CGameOptions::watchdogTimeout"]
[::std::mem::offset_of!(CGameOptions, watchdogTimeout) - 16usize];
["Offset of field: CGameOptions::scriptVersion"]
[::std::mem::offset_of!(CGameOptions, scriptVersion) - 20usize];
["Offset of field: CGameOptions::scriptProfiling"]
[::std::mem::offset_of!(CGameOptions, scriptProfiling) - 22usize];
["Offset of field: CGameOptions::scriptsBlobPath"]
[::std::mem::offset_of!(CGameOptions, scriptsBlobPath) - 24usize];
["Offset of field: CGameOptions::tweakdbBlobPath"]
[::std::mem::offset_of!(CGameOptions, tweakdbBlobPath) - 56usize];
["Offset of field: CGameOptions::unattended58"]
[::std::mem::offset_of!(CGameOptions, unattended58) - 88usize];
["Offset of field: CGameOptions::unattended59"]
[::std::mem::offset_of!(CGameOptions, unattended59) - 89usize];
["Offset of field: CGameOptions::unattended5A"]
[::std::mem::offset_of!(CGameOptions, unattended5A) - 90usize];
["Offset of field: CGameOptions::forceRawTweakDB"]
[::std::mem::offset_of!(CGameOptions, forceRawTweakDB) - 91usize];
["Offset of field: CGameOptions::pvdDumpToFile"]
[::std::mem::offset_of!(CGameOptions, pvdDumpToFile) - 92usize];
["Offset of field: CGameOptions::profiler"]
[::std::mem::offset_of!(CGameOptions, profiler) - 93usize];
["Offset of field: CGameOptions::unk5E"]
[::std::mem::offset_of!(CGameOptions, unk5E) - 94usize];
["Offset of field: CGameOptions::unk5F"]
[::std::mem::offset_of!(CGameOptions, unk5F) - 95usize];
["Offset of field: CGameOptions::unattended60"]
[::std::mem::offset_of!(CGameOptions, unattended60) - 96usize];
["Offset of field: CGameOptions::unk68"]
[::std::mem::offset_of!(CGameOptions, unk68) - 104usize];
["Offset of field: CGameOptions::automator"]
[::std::mem::offset_of!(CGameOptions, automator) - 112usize];
["Offset of field: CGameOptions::windowCaption"]
[::std::mem::offset_of!(CGameOptions, windowCaption) - 144usize];
["Offset of field: CGameOptions::isBackendGameEngine"]
[::std::mem::offset_of!(CGameOptions, isBackendGameEngine) - 176usize];
["Offset of field: CGameOptions::unkB1"]
[::std::mem::offset_of!(CGameOptions, unkB1) - 177usize];
["Offset of field: CGameOptions::nochroma"]
[::std::mem::offset_of!(CGameOptions, nochroma) - 178usize];
};
impl Default for CGameOptions {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
pub struct CBaseGameApplication__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct CBaseGameApplication {
pub vtable_: *const CBaseGameApplication__bindgen_vtable,
pub unk8: root::RED4ext::CBaseGameApplication_Unk8,
pub unk190: i64,
pub unk198: i64,
pub unk1A0: i64,
pub unk1A8: i64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CBaseGameApplication_Unk8 {
pub unk00: i8,
pub unk08: i64,
pub unk10: i32,
pub unk14: i32,
pub unk18: i64,
pub unk20: i8,
pub unk28: i64,
pub unk30: i32,
pub unk34: i32,
pub unk38: i64,
pub unk40: i8,
pub unk48: i64,
pub unk50: i32,
pub unk54: i32,
pub unk58: i64,
pub unk60: i8,
pub unk68: i64,
pub unk70: i32,
pub unk74: i32,
pub unk78: i64,
pub unk80: i8,
pub unk88: i64,
pub unk90: i32,
pub unk94: i32,
pub unk98: i64,
pub unkA0: i8,
pub unkA8: i64,
pub unkB0: i32,
pub unkB4: i32,
pub unkB8: i64,
pub unkC0: i8,
pub unkC8: i64,
pub unkD0: i32,
pub unkD4: i32,
pub unkD8: i64,
pub unkE0: i8,
pub unkE8: i64,
pub unkF0: i32,
pub unkF4: i32,
pub unkF8: i64,
pub unk100: i8,
pub unk108: i64,
pub unk110: i32,
pub unk114: i32,
pub unk118: i64,
pub unk120: i8,
pub unk128: i64,
pub unk130: i32,
pub unk134: i32,
pub unk138: i64,
pub unk140: i8,
pub unk148: i64,
pub unk150: i32,
pub unk154: i32,
pub unk158: i64,
pub unk160: i8,
pub unk168: i64,
pub unk170: i32,
pub unk174: i32,
pub unk178: i64,
pub unk180: i16,
pub unk182: i8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseGameApplication_Unk8"]
[::std::mem::size_of::<CBaseGameApplication_Unk8>() - 392usize];
["Alignment of CBaseGameApplication_Unk8"]
[::std::mem::align_of::<CBaseGameApplication_Unk8>() - 8usize];
["Offset of field: CBaseGameApplication_Unk8::unk00"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk00) - 0usize];
["Offset of field: CBaseGameApplication_Unk8::unk08"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk08) - 8usize];
["Offset of field: CBaseGameApplication_Unk8::unk10"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk10) - 16usize];
["Offset of field: CBaseGameApplication_Unk8::unk14"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk14) - 20usize];
["Offset of field: CBaseGameApplication_Unk8::unk18"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk18) - 24usize];
["Offset of field: CBaseGameApplication_Unk8::unk20"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk20) - 32usize];
["Offset of field: CBaseGameApplication_Unk8::unk28"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk28) - 40usize];
["Offset of field: CBaseGameApplication_Unk8::unk30"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk30) - 48usize];
["Offset of field: CBaseGameApplication_Unk8::unk34"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk34) - 52usize];
["Offset of field: CBaseGameApplication_Unk8::unk38"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk38) - 56usize];
["Offset of field: CBaseGameApplication_Unk8::unk40"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk40) - 64usize];
["Offset of field: CBaseGameApplication_Unk8::unk48"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk48) - 72usize];
["Offset of field: CBaseGameApplication_Unk8::unk50"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk50) - 80usize];
["Offset of field: CBaseGameApplication_Unk8::unk54"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk54) - 84usize];
["Offset of field: CBaseGameApplication_Unk8::unk58"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk58) - 88usize];
["Offset of field: CBaseGameApplication_Unk8::unk60"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk60) - 96usize];
["Offset of field: CBaseGameApplication_Unk8::unk68"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk68) - 104usize];
["Offset of field: CBaseGameApplication_Unk8::unk70"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk70) - 112usize];
["Offset of field: CBaseGameApplication_Unk8::unk74"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk74) - 116usize];
["Offset of field: CBaseGameApplication_Unk8::unk78"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk78) - 120usize];
["Offset of field: CBaseGameApplication_Unk8::unk80"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk80) - 128usize];
["Offset of field: CBaseGameApplication_Unk8::unk88"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk88) - 136usize];
["Offset of field: CBaseGameApplication_Unk8::unk90"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk90) - 144usize];
["Offset of field: CBaseGameApplication_Unk8::unk94"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk94) - 148usize];
["Offset of field: CBaseGameApplication_Unk8::unk98"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk98) - 152usize];
["Offset of field: CBaseGameApplication_Unk8::unkA0"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkA0) - 160usize];
["Offset of field: CBaseGameApplication_Unk8::unkA8"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkA8) - 168usize];
["Offset of field: CBaseGameApplication_Unk8::unkB0"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkB0) - 176usize];
["Offset of field: CBaseGameApplication_Unk8::unkB4"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkB4) - 180usize];
["Offset of field: CBaseGameApplication_Unk8::unkB8"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkB8) - 184usize];
["Offset of field: CBaseGameApplication_Unk8::unkC0"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkC0) - 192usize];
["Offset of field: CBaseGameApplication_Unk8::unkC8"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkC8) - 200usize];
["Offset of field: CBaseGameApplication_Unk8::unkD0"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkD0) - 208usize];
["Offset of field: CBaseGameApplication_Unk8::unkD4"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkD4) - 212usize];
["Offset of field: CBaseGameApplication_Unk8::unkD8"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkD8) - 216usize];
["Offset of field: CBaseGameApplication_Unk8::unkE0"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkE0) - 224usize];
["Offset of field: CBaseGameApplication_Unk8::unkE8"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkE8) - 232usize];
["Offset of field: CBaseGameApplication_Unk8::unkF0"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkF0) - 240usize];
["Offset of field: CBaseGameApplication_Unk8::unkF4"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkF4) - 244usize];
["Offset of field: CBaseGameApplication_Unk8::unkF8"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unkF8) - 248usize];
["Offset of field: CBaseGameApplication_Unk8::unk100"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk100) - 256usize];
["Offset of field: CBaseGameApplication_Unk8::unk108"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk108) - 264usize];
["Offset of field: CBaseGameApplication_Unk8::unk110"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk110) - 272usize];
["Offset of field: CBaseGameApplication_Unk8::unk114"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk114) - 276usize];
["Offset of field: CBaseGameApplication_Unk8::unk118"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk118) - 280usize];
["Offset of field: CBaseGameApplication_Unk8::unk120"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk120) - 288usize];
["Offset of field: CBaseGameApplication_Unk8::unk128"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk128) - 296usize];
["Offset of field: CBaseGameApplication_Unk8::unk130"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk130) - 304usize];
["Offset of field: CBaseGameApplication_Unk8::unk134"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk134) - 308usize];
["Offset of field: CBaseGameApplication_Unk8::unk138"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk138) - 312usize];
["Offset of field: CBaseGameApplication_Unk8::unk140"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk140) - 320usize];
["Offset of field: CBaseGameApplication_Unk8::unk148"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk148) - 328usize];
["Offset of field: CBaseGameApplication_Unk8::unk150"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk150) - 336usize];
["Offset of field: CBaseGameApplication_Unk8::unk154"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk154) - 340usize];
["Offset of field: CBaseGameApplication_Unk8::unk158"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk158) - 344usize];
["Offset of field: CBaseGameApplication_Unk8::unk160"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk160) - 352usize];
["Offset of field: CBaseGameApplication_Unk8::unk168"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk168) - 360usize];
["Offset of field: CBaseGameApplication_Unk8::unk170"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk170) - 368usize];
["Offset of field: CBaseGameApplication_Unk8::unk174"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk174) - 372usize];
["Offset of field: CBaseGameApplication_Unk8::unk178"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk178) - 376usize];
["Offset of field: CBaseGameApplication_Unk8::unk180"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk180) - 384usize];
["Offset of field: CBaseGameApplication_Unk8::unk182"]
[::std::mem::offset_of!(CBaseGameApplication_Unk8, unk182) - 386usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseGameApplication"]
[::std::mem::size_of::<CBaseGameApplication>() - 432usize];
["Alignment of CBaseGameApplication"]
[::std::mem::align_of::<CBaseGameApplication>() - 8usize];
["Offset of field: CBaseGameApplication::unk8"]
[::std::mem::offset_of!(CBaseGameApplication, unk8) - 8usize];
["Offset of field: CBaseGameApplication::unk190"]
[::std::mem::offset_of!(CBaseGameApplication, unk190) - 400usize];
["Offset of field: CBaseGameApplication::unk198"]
[::std::mem::offset_of!(CBaseGameApplication, unk198) - 408usize];
["Offset of field: CBaseGameApplication::unk1A0"]
[::std::mem::offset_of!(CBaseGameApplication, unk1A0) - 416usize];
["Offset of field: CBaseGameApplication::unk1A8"]
[::std::mem::offset_of!(CBaseGameApplication, unk1A8) - 424usize];
};
impl Default for CBaseGameApplication {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
unsafe extern "C" {
#[link_name = "\u{1}??1CBaseGameApplication@RED4ext@@UEAA@XZ"]
pub fn CBaseGameApplication_CBaseGameApplication_destructor(
this: *mut root::RED4ext::CBaseGameApplication,
);
}
#[repr(C)]
pub struct CGameApplication {
pub _base: root::RED4ext::CBaseGameApplication,
pub options: root::RED4ext::CGameOptions,
pub statesTypes: root::RED4ext::DynArray<root::RED4ext::EGameStateType::Type>,
pub states: root::RED4ext::DynArray<*mut root::RED4ext::IGameState>,
pub unk288: i32,
pub currState: *mut root::RED4ext::IGameState,
pub nextState: *mut root::RED4ext::IGameState,
pub status: root::RED4ext::EGameStateStatus::Type,
pub unk2A4: i32,
pub name: *const ::std::os::raw::c_char,
pub retCode: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CGameApplication"][::std::mem::size_of::<CGameApplication>() - 696usize];
["Alignment of CGameApplication"][::std::mem::align_of::<CGameApplication>() - 8usize];
["Offset of field: CGameApplication::options"]
[::std::mem::offset_of!(CGameApplication, options) - 432usize];
["Offset of field: CGameApplication::statesTypes"]
[::std::mem::offset_of!(CGameApplication, statesTypes) - 616usize];
["Offset of field: CGameApplication::states"]
[::std::mem::offset_of!(CGameApplication, states) - 632usize];
["Offset of field: CGameApplication::unk288"]
[::std::mem::offset_of!(CGameApplication, unk288) - 648usize];
["Offset of field: CGameApplication::currState"]
[::std::mem::offset_of!(CGameApplication, currState) - 656usize];
["Offset of field: CGameApplication::nextState"]
[::std::mem::offset_of!(CGameApplication, nextState) - 664usize];
["Offset of field: CGameApplication::status"]
[::std::mem::offset_of!(CGameApplication, status) - 672usize];
["Offset of field: CGameApplication::unk2A4"]
[::std::mem::offset_of!(CGameApplication, unk2A4) - 676usize];
["Offset of field: CGameApplication::name"]
[::std::mem::offset_of!(CGameApplication, name) - 680usize];
["Offset of field: CGameApplication::retCode"]
[::std::mem::offset_of!(CGameApplication, retCode) - 688usize];
};
impl Default for CGameApplication {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct RefCnt {
pub strongRefs: u32,
pub weakRefs: u32,
}
pub type RefCnt_AllocatorType = root::RED4ext::Memory::RefCountAllocator;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RefCnt"][::std::mem::size_of::<RefCnt>() - 8usize];
["Alignment of RefCnt"][::std::mem::align_of::<RefCnt>() - 4usize];
["Offset of field: RefCnt::strongRefs"]
[::std::mem::offset_of!(RefCnt, strongRefs) - 0usize];
["Offset of field: RefCnt::weakRefs"]
[::std::mem::offset_of!(RefCnt, weakRefs) - 4usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct SharedPtrBase<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub instance: *mut T,
pub refCount: *mut root::RED4ext::RefCnt,
}
impl<T> Default for SharedPtrBase<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct SharedPtrWithAccess<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub _base: root::RED4ext::SharedPtrBase<T>,
}
pub type SharedPtrWithAccess_BaseType<T> = root::RED4ext::SharedPtrBase<T>;
impl<T> Default for SharedPtrWithAccess<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct WeakPtrWithAccess<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub _base: root::RED4ext::SharedPtrBase<T>,
}
pub type WeakPtrWithAccess_BaseType<T> = root::RED4ext::SharedPtrBase<T>;
impl<T> Default for WeakPtrWithAccess<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct SharedPtr<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub _base: root::RED4ext::SharedPtrWithAccess<T>,
}
pub type SharedPtr_BaseType<T> = root::RED4ext::SharedPtrWithAccess<T>;
impl<T> Default for SharedPtr<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct WeakPtr<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub _base: root::RED4ext::WeakPtrWithAccess<T>,
}
pub type WeakPtr_BaseType<T> = root::RED4ext::WeakPtrWithAccess<T>;
impl<T> Default for WeakPtr<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Handle<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub _base: root::RED4ext::SharedPtrWithAccess<T>,
}
pub type Handle_BaseType<T> = root::RED4ext::SharedPtrWithAccess<T>;
impl<T> Default for Handle<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct WeakHandle<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub _base: root::RED4ext::WeakPtrWithAccess<T>,
}
pub type WeakHandle_BaseType<T> = root::RED4ext::WeakPtrWithAccess<T>;
impl<T> Default for WeakHandle<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub mod services {
#[allow(unused_imports)]
use self::super::super::super::root;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GameServicesGalaxy {
pub unk00: [u8; 504usize],
}
pub const GameServicesGalaxy_NAME: &[u8; 27] = b"servicesGameServicesGalaxy\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@GameServicesGalaxy@services@RED4ext@@2QEBDEB"]
pub static GameServicesGalaxy_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of GameServicesGalaxy"]
[::std::mem::size_of::<GameServicesGalaxy>() - 504usize];
["Alignment of GameServicesGalaxy"]
[::std::mem::align_of::<GameServicesGalaxy>() - 1usize];
["Offset of field: GameServicesGalaxy::unk00"]
[::std::mem::offset_of!(GameServicesGalaxy, unk00) - 0usize];
};
impl Default for GameServicesGalaxy {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GameServices {
pub _base: root::RED4ext::services::GameServicesGalaxy,
pub unk1F8: [u8; 1232usize],
}
pub const GameServices_NAME: &[u8; 21] = b"servicesGameServices\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@GameServices@services@RED4ext@@2QEBDEB"]
pub static GameServices_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of GameServices"][::std::mem::size_of::<GameServices>() - 1736usize];
["Alignment of GameServices"][::std::mem::align_of::<GameServices>() - 1usize];
["Offset of field: GameServices::unk1F8"]
[::std::mem::offset_of!(GameServices, unk1F8) - 504usize];
};
impl Default for GameServices {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
}
pub type servicesGameServicesGalaxy = root::RED4ext::services::GameServicesGalaxy;
pub type servicesGameServices = root::RED4ext::services::GameServices;
pub mod EEngineState {
pub type Type = i32;
pub const Idle: Type = 0;
pub const BaseInitialization: Type = 1;
pub const Initialization: Type = 2;
pub const Running: Type = 3;
}
#[repr(C)]
pub struct GameInstance__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct GameInstance {
pub vtable_: *const GameInstance__bindgen_vtable,
pub systemMap: root::RED4ext::HashMap<
*mut root::RED4ext::CBaseRTTIType,
root::RED4ext::Handle<root::RED4ext::IScriptable>,
>,
pub systemInstances:
root::RED4ext::DynArray<root::RED4ext::Handle<root::RED4ext::IScriptable>>,
pub systemImplementations: root::RED4ext::HashMap<
*mut root::RED4ext::CBaseRTTIType,
*mut root::RED4ext::CBaseRTTIType,
>,
pub unk78: [usize; 24usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of GameInstance"][::std::mem::size_of::<GameInstance>() - 312usize];
["Alignment of GameInstance"][::std::mem::align_of::<GameInstance>() - 8usize];
["Offset of field: GameInstance::systemMap"]
[::std::mem::offset_of!(GameInstance, systemMap) - 8usize];
["Offset of field: GameInstance::systemInstances"]
[::std::mem::offset_of!(GameInstance, systemInstances) - 56usize];
["Offset of field: GameInstance::systemImplementations"]
[::std::mem::offset_of!(GameInstance, systemImplementations) - 72usize];
["Offset of field: GameInstance::unk78"]
[::std::mem::offset_of!(GameInstance, unk78) - 120usize];
};
impl Default for GameInstance {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
pub struct CBaseEngine__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct CBaseEngine {
pub vtable_: *const CBaseEngine__bindgen_vtable,
pub unk8: f64,
pub unk10: f32,
pub unk14: f32,
pub unk18: f32,
pub unk1C: f32,
pub unk20: f32,
pub unk28: i64,
pub unk30: i32,
pub unk34: i8,
pub scriptsTimestamp: u64,
pub unk40: i8,
pub terminationLock: root::RED4ext::SharedSpinLock,
pub unk44: i32,
pub terminating: i8,
pub unk49: i8,
pub unk4A: i8,
pub unk4B: i8,
pub exitStatus: i32,
pub unk50: i32,
pub scriptsLoaded: bool,
pub scriptsSilentCompilation: bool,
pub scriptsSilentValidation: bool,
pub unk57: i8,
pub unk58: i8,
pub unk5A: i16,
pub interopStartingPort: i32,
pub unk60: i64,
pub unk68: i64,
pub scriptsCompilationErrors: root::RED4ext::CString,
pub scriptsValidationErrors: root::RED4ext::DynArray<root::RED4ext::CString>,
pub unkA0: i64,
pub unkA8: i64,
pub unkB0: i64,
pub unkB8: i64,
pub padC0: [u8; 16usize],
pub unkD0: *mut root::RED4ext::CBaseEngine_UnkD0,
pub unkD8: f64,
pub unkE0: f64,
pub unkE8: i32,
pub unkF0: i64,
pub unkF8: i64,
pub unk100: i64,
pub engineState: root::RED4ext::EEngineState::Type,
pub unk10C: i32,
pub unk110: i32,
pub unk118: *mut root::RED4ext::CBaseEngine_Unk108,
pub unk120: root::RED4ext::CBaseEngine_Unk110,
pub buildString: root::RED4ext::CString,
pub scriptsBlobPath: root::RED4ext::CString,
pub unk170: i32,
pub unk174: i8,
pub unk178: i64,
pub unk180: i64,
pub unk188: i64,
pub unk190: i64,
pub unk198: [i8; 178usize],
pub unk24C: i32,
pub unk250: [i8; 64usize],
pub unk290: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub unk2A0: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub unk2B0: i64,
pub unk2B8: i64,
pub unk2C0: i64,
pub unk2C8: i64,
pub unk2D0: i32,
pub isEP1: bool,
pub unk2D8: i64,
pub unk2E0: i64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CBaseEngine_UnkD0 {
pub pad0: [u8; 320usize],
pub unk140: u32,
pub pad144: [u8; 32usize],
pub unk164: u32,
pub pad158: [u8; 12usize],
pub unk174: u32,
pub hWnd: *mut ::std::os::raw::c_void,
pub pad180: [u8; 9usize],
pub isClipped: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseEngine_UnkD0"][::std::mem::size_of::<CBaseEngine_UnkD0>() - 400usize];
["Alignment of CBaseEngine_UnkD0"]
[::std::mem::align_of::<CBaseEngine_UnkD0>() - 8usize];
["Offset of field: CBaseEngine_UnkD0::pad0"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, pad0) - 0usize];
["Offset of field: CBaseEngine_UnkD0::unk140"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, unk140) - 320usize];
["Offset of field: CBaseEngine_UnkD0::pad144"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, pad144) - 324usize];
["Offset of field: CBaseEngine_UnkD0::unk164"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, unk164) - 356usize];
["Offset of field: CBaseEngine_UnkD0::pad158"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, pad158) - 360usize];
["Offset of field: CBaseEngine_UnkD0::unk174"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, unk174) - 372usize];
["Offset of field: CBaseEngine_UnkD0::hWnd"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, hWnd) - 376usize];
["Offset of field: CBaseEngine_UnkD0::pad180"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, pad180) - 384usize];
["Offset of field: CBaseEngine_UnkD0::isClipped"]
[::std::mem::offset_of!(CBaseEngine_UnkD0, isClipped) - 393usize];
};
impl Default for CBaseEngine_UnkD0 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CBaseEngine_Unk108 {
pub unk0: i64,
pub unk8: i64,
pub unk10: i64,
pub unk18: i32,
pub unk1C: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseEngine_Unk108"][::std::mem::size_of::<CBaseEngine_Unk108>() - 32usize];
["Alignment of CBaseEngine_Unk108"]
[::std::mem::align_of::<CBaseEngine_Unk108>() - 8usize];
["Offset of field: CBaseEngine_Unk108::unk0"]
[::std::mem::offset_of!(CBaseEngine_Unk108, unk0) - 0usize];
["Offset of field: CBaseEngine_Unk108::unk8"]
[::std::mem::offset_of!(CBaseEngine_Unk108, unk8) - 8usize];
["Offset of field: CBaseEngine_Unk108::unk10"]
[::std::mem::offset_of!(CBaseEngine_Unk108, unk10) - 16usize];
["Offset of field: CBaseEngine_Unk108::unk18"]
[::std::mem::offset_of!(CBaseEngine_Unk108, unk18) - 24usize];
["Offset of field: CBaseEngine_Unk108::unk1C"]
[::std::mem::offset_of!(CBaseEngine_Unk108, unk1C) - 28usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CBaseEngine_Unk110 {
pub unk0: i8,
pub unk4: i32,
pub unk8: i32,
pub unkC: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseEngine_Unk110"][::std::mem::size_of::<CBaseEngine_Unk110>() - 16usize];
["Alignment of CBaseEngine_Unk110"]
[::std::mem::align_of::<CBaseEngine_Unk110>() - 4usize];
["Offset of field: CBaseEngine_Unk110::unk0"]
[::std::mem::offset_of!(CBaseEngine_Unk110, unk0) - 0usize];
["Offset of field: CBaseEngine_Unk110::unk4"]
[::std::mem::offset_of!(CBaseEngine_Unk110, unk4) - 4usize];
["Offset of field: CBaseEngine_Unk110::unk8"]
[::std::mem::offset_of!(CBaseEngine_Unk110, unk8) - 8usize];
["Offset of field: CBaseEngine_Unk110::unkC"]
[::std::mem::offset_of!(CBaseEngine_Unk110, unkC) - 12usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseEngine"][::std::mem::size_of::<CBaseEngine>() - 744usize];
["Alignment of CBaseEngine"][::std::mem::align_of::<CBaseEngine>() - 8usize];
["Offset of field: CBaseEngine::unk8"]
[::std::mem::offset_of!(CBaseEngine, unk8) - 8usize];
["Offset of field: CBaseEngine::unk10"]
[::std::mem::offset_of!(CBaseEngine, unk10) - 16usize];
["Offset of field: CBaseEngine::unk14"]
[::std::mem::offset_of!(CBaseEngine, unk14) - 20usize];
["Offset of field: CBaseEngine::unk18"]
[::std::mem::offset_of!(CBaseEngine, unk18) - 24usize];
["Offset of field: CBaseEngine::unk1C"]
[::std::mem::offset_of!(CBaseEngine, unk1C) - 28usize];
["Offset of field: CBaseEngine::unk20"]
[::std::mem::offset_of!(CBaseEngine, unk20) - 32usize];
["Offset of field: CBaseEngine::unk28"]
[::std::mem::offset_of!(CBaseEngine, unk28) - 40usize];
["Offset of field: CBaseEngine::unk30"]
[::std::mem::offset_of!(CBaseEngine, unk30) - 48usize];
["Offset of field: CBaseEngine::unk34"]
[::std::mem::offset_of!(CBaseEngine, unk34) - 52usize];
["Offset of field: CBaseEngine::scriptsTimestamp"]
[::std::mem::offset_of!(CBaseEngine, scriptsTimestamp) - 56usize];
["Offset of field: CBaseEngine::unk40"]
[::std::mem::offset_of!(CBaseEngine, unk40) - 64usize];
["Offset of field: CBaseEngine::terminationLock"]
[::std::mem::offset_of!(CBaseEngine, terminationLock) - 65usize];
["Offset of field: CBaseEngine::unk44"]
[::std::mem::offset_of!(CBaseEngine, unk44) - 68usize];
["Offset of field: CBaseEngine::terminating"]
[::std::mem::offset_of!(CBaseEngine, terminating) - 72usize];
["Offset of field: CBaseEngine::unk49"]
[::std::mem::offset_of!(CBaseEngine, unk49) - 73usize];
["Offset of field: CBaseEngine::unk4A"]
[::std::mem::offset_of!(CBaseEngine, unk4A) - 74usize];
["Offset of field: CBaseEngine::unk4B"]
[::std::mem::offset_of!(CBaseEngine, unk4B) - 75usize];
["Offset of field: CBaseEngine::exitStatus"]
[::std::mem::offset_of!(CBaseEngine, exitStatus) - 76usize];
["Offset of field: CBaseEngine::unk50"]
[::std::mem::offset_of!(CBaseEngine, unk50) - 80usize];
["Offset of field: CBaseEngine::scriptsLoaded"]
[::std::mem::offset_of!(CBaseEngine, scriptsLoaded) - 84usize];
["Offset of field: CBaseEngine::scriptsSilentCompilation"]
[::std::mem::offset_of!(CBaseEngine, scriptsSilentCompilation) - 85usize];
["Offset of field: CBaseEngine::scriptsSilentValidation"]
[::std::mem::offset_of!(CBaseEngine, scriptsSilentValidation) - 86usize];
["Offset of field: CBaseEngine::unk57"]
[::std::mem::offset_of!(CBaseEngine, unk57) - 87usize];
["Offset of field: CBaseEngine::unk58"]
[::std::mem::offset_of!(CBaseEngine, unk58) - 88usize];
["Offset of field: CBaseEngine::unk5A"]
[::std::mem::offset_of!(CBaseEngine, unk5A) - 90usize];
["Offset of field: CBaseEngine::interopStartingPort"]
[::std::mem::offset_of!(CBaseEngine, interopStartingPort) - 92usize];
["Offset of field: CBaseEngine::unk60"]
[::std::mem::offset_of!(CBaseEngine, unk60) - 96usize];
["Offset of field: CBaseEngine::unk68"]
[::std::mem::offset_of!(CBaseEngine, unk68) - 104usize];
["Offset of field: CBaseEngine::scriptsCompilationErrors"]
[::std::mem::offset_of!(CBaseEngine, scriptsCompilationErrors) - 112usize];
["Offset of field: CBaseEngine::scriptsValidationErrors"]
[::std::mem::offset_of!(CBaseEngine, scriptsValidationErrors) - 144usize];
["Offset of field: CBaseEngine::unkA0"]
[::std::mem::offset_of!(CBaseEngine, unkA0) - 160usize];
["Offset of field: CBaseEngine::unkA8"]
[::std::mem::offset_of!(CBaseEngine, unkA8) - 168usize];
["Offset of field: CBaseEngine::unkB0"]
[::std::mem::offset_of!(CBaseEngine, unkB0) - 176usize];
["Offset of field: CBaseEngine::unkB8"]
[::std::mem::offset_of!(CBaseEngine, unkB8) - 184usize];
["Offset of field: CBaseEngine::padC0"]
[::std::mem::offset_of!(CBaseEngine, padC0) - 192usize];
["Offset of field: CBaseEngine::unkD0"]
[::std::mem::offset_of!(CBaseEngine, unkD0) - 208usize];
["Offset of field: CBaseEngine::unkD8"]
[::std::mem::offset_of!(CBaseEngine, unkD8) - 216usize];
["Offset of field: CBaseEngine::unkE0"]
[::std::mem::offset_of!(CBaseEngine, unkE0) - 224usize];
["Offset of field: CBaseEngine::unkE8"]
[::std::mem::offset_of!(CBaseEngine, unkE8) - 232usize];
["Offset of field: CBaseEngine::unkF0"]
[::std::mem::offset_of!(CBaseEngine, unkF0) - 240usize];
["Offset of field: CBaseEngine::unkF8"]
[::std::mem::offset_of!(CBaseEngine, unkF8) - 248usize];
["Offset of field: CBaseEngine::unk100"]
[::std::mem::offset_of!(CBaseEngine, unk100) - 256usize];
["Offset of field: CBaseEngine::engineState"]
[::std::mem::offset_of!(CBaseEngine, engineState) - 264usize];
["Offset of field: CBaseEngine::unk10C"]
[::std::mem::offset_of!(CBaseEngine, unk10C) - 268usize];
["Offset of field: CBaseEngine::unk110"]
[::std::mem::offset_of!(CBaseEngine, unk110) - 272usize];
["Offset of field: CBaseEngine::unk118"]
[::std::mem::offset_of!(CBaseEngine, unk118) - 280usize];
["Offset of field: CBaseEngine::unk120"]
[::std::mem::offset_of!(CBaseEngine, unk120) - 288usize];
["Offset of field: CBaseEngine::buildString"]
[::std::mem::offset_of!(CBaseEngine, buildString) - 304usize];
["Offset of field: CBaseEngine::scriptsBlobPath"]
[::std::mem::offset_of!(CBaseEngine, scriptsBlobPath) - 336usize];
["Offset of field: CBaseEngine::unk170"]
[::std::mem::offset_of!(CBaseEngine, unk170) - 368usize];
["Offset of field: CBaseEngine::unk174"]
[::std::mem::offset_of!(CBaseEngine, unk174) - 372usize];
["Offset of field: CBaseEngine::unk178"]
[::std::mem::offset_of!(CBaseEngine, unk178) - 376usize];
["Offset of field: CBaseEngine::unk180"]
[::std::mem::offset_of!(CBaseEngine, unk180) - 384usize];
["Offset of field: CBaseEngine::unk188"]
[::std::mem::offset_of!(CBaseEngine, unk188) - 392usize];
["Offset of field: CBaseEngine::unk190"]
[::std::mem::offset_of!(CBaseEngine, unk190) - 400usize];
["Offset of field: CBaseEngine::unk198"]
[::std::mem::offset_of!(CBaseEngine, unk198) - 408usize];
["Offset of field: CBaseEngine::unk24C"]
[::std::mem::offset_of!(CBaseEngine, unk24C) - 588usize];
["Offset of field: CBaseEngine::unk250"]
[::std::mem::offset_of!(CBaseEngine, unk250) - 592usize];
["Offset of field: CBaseEngine::unk290"]
[::std::mem::offset_of!(CBaseEngine, unk290) - 656usize];
["Offset of field: CBaseEngine::unk2A0"]
[::std::mem::offset_of!(CBaseEngine, unk2A0) - 672usize];
["Offset of field: CBaseEngine::unk2B0"]
[::std::mem::offset_of!(CBaseEngine, unk2B0) - 688usize];
["Offset of field: CBaseEngine::unk2B8"]
[::std::mem::offset_of!(CBaseEngine, unk2B8) - 696usize];
["Offset of field: CBaseEngine::unk2C0"]
[::std::mem::offset_of!(CBaseEngine, unk2C0) - 704usize];
["Offset of field: CBaseEngine::unk2C8"]
[::std::mem::offset_of!(CBaseEngine, unk2C8) - 712usize];
["Offset of field: CBaseEngine::unk2D0"]
[::std::mem::offset_of!(CBaseEngine, unk2D0) - 720usize];
["Offset of field: CBaseEngine::isEP1"]
[::std::mem::offset_of!(CBaseEngine, isEP1) - 724usize];
["Offset of field: CBaseEngine::unk2D8"]
[::std::mem::offset_of!(CBaseEngine, unk2D8) - 728usize];
["Offset of field: CBaseEngine::unk2E0"]
[::std::mem::offset_of!(CBaseEngine, unk2E0) - 736usize];
};
impl Default for CBaseEngine {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
pub struct BaseGameEngine {
pub _base: root::RED4ext::CBaseEngine,
pub unk2E8: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of BaseGameEngine"][::std::mem::size_of::<BaseGameEngine>() - 752usize];
["Alignment of BaseGameEngine"][::std::mem::align_of::<BaseGameEngine>() - 8usize];
["Offset of field: BaseGameEngine::unk2E8"]
[::std::mem::offset_of!(BaseGameEngine, unk2E8) - 744usize];
};
impl Default for BaseGameEngine {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
pub struct CGameEngine {
pub _base: root::RED4ext::BaseGameEngine,
pub unk2F0: i64,
pub unk2F8: i64,
pub unk300: i32,
pub unk304: i32,
pub framework: *mut root::RED4ext::CGameEngine_CGameFramework,
pub gameServices: *mut root::RED4ext::services::GameServices,
pub unk318: i64,
pub unk320: i64,
pub unk328: i64,
pub unk330: i64,
pub unk338: i64,
pub unk340: i32,
pub unk348: i64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CGameEngine_CGameFramework {
pub unk00: usize,
pub unk08: usize,
pub gameInstance: *mut root::RED4ext::GameInstance,
pub unk18: usize,
pub unk20: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CGameEngine_CGameFramework"]
[::std::mem::size_of::<CGameEngine_CGameFramework>() - 40usize];
["Alignment of CGameEngine_CGameFramework"]
[::std::mem::align_of::<CGameEngine_CGameFramework>() - 8usize];
["Offset of field: CGameEngine_CGameFramework::unk00"]
[::std::mem::offset_of!(CGameEngine_CGameFramework, unk00) - 0usize];
["Offset of field: CGameEngine_CGameFramework::unk08"]
[::std::mem::offset_of!(CGameEngine_CGameFramework, unk08) - 8usize];
["Offset of field: CGameEngine_CGameFramework::gameInstance"]
[::std::mem::offset_of!(CGameEngine_CGameFramework, gameInstance) - 16usize];
["Offset of field: CGameEngine_CGameFramework::unk18"]
[::std::mem::offset_of!(CGameEngine_CGameFramework, unk18) - 24usize];
["Offset of field: CGameEngine_CGameFramework::unk20"]
[::std::mem::offset_of!(CGameEngine_CGameFramework, unk20) - 32usize];
};
impl Default for CGameEngine_CGameFramework {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CGameEngine"][::std::mem::size_of::<CGameEngine>() - 848usize];
["Alignment of CGameEngine"][::std::mem::align_of::<CGameEngine>() - 8usize];
["Offset of field: CGameEngine::unk2F0"]
[::std::mem::offset_of!(CGameEngine, unk2F0) - 752usize];
["Offset of field: CGameEngine::unk2F8"]
[::std::mem::offset_of!(CGameEngine, unk2F8) - 760usize];
["Offset of field: CGameEngine::unk300"]
[::std::mem::offset_of!(CGameEngine, unk300) - 768usize];
["Offset of field: CGameEngine::unk304"]
[::std::mem::offset_of!(CGameEngine, unk304) - 772usize];
["Offset of field: CGameEngine::framework"]
[::std::mem::offset_of!(CGameEngine, framework) - 776usize];
["Offset of field: CGameEngine::gameServices"]
[::std::mem::offset_of!(CGameEngine, gameServices) - 784usize];
["Offset of field: CGameEngine::unk318"]
[::std::mem::offset_of!(CGameEngine, unk318) - 792usize];
["Offset of field: CGameEngine::unk320"]
[::std::mem::offset_of!(CGameEngine, unk320) - 800usize];
["Offset of field: CGameEngine::unk328"]
[::std::mem::offset_of!(CGameEngine, unk328) - 808usize];
["Offset of field: CGameEngine::unk330"]
[::std::mem::offset_of!(CGameEngine, unk330) - 816usize];
["Offset of field: CGameEngine::unk338"]
[::std::mem::offset_of!(CGameEngine, unk338) - 824usize];
["Offset of field: CGameEngine::unk340"]
[::std::mem::offset_of!(CGameEngine, unk340) - 832usize];
["Offset of field: CGameEngine::unk348"]
[::std::mem::offset_of!(CGameEngine, unk348) - 840usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Get@CGameEngine@RED4ext@@SAPEAU12@XZ"]
pub fn CGameEngine_Get() -> *mut root::RED4ext::CGameEngine;
}
impl Default for CGameEngine {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CGameEngine {
#[inline]
pub unsafe fn Get() -> *mut root::RED4ext::CGameEngine {
CGameEngine_Get()
}
}
pub mod EGameStateType {
pub type Type = u32;
pub const BaseInitialization: Type = 0;
pub const Initialization: Type = 1;
pub const Running: Type = 2;
pub const Shutdown: Type = 3;
}
#[repr(C)]
pub struct IGameState__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct IGameState {
pub vtable_: *const IGameState__bindgen_vtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IGameState"][::std::mem::size_of::<IGameState>() - 8usize];
["Alignment of IGameState"][::std::mem::align_of::<IGameState>() - 8usize];
};
impl Default for IGameState {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CBaseInitializationState {
pub _base: root::RED4ext::IGameState,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseInitializationState"]
[::std::mem::size_of::<CBaseInitializationState>() - 8usize];
["Alignment of CBaseInitializationState"]
[::std::mem::align_of::<CBaseInitializationState>() - 8usize];
};
impl Default for CBaseInitializationState {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CInitializationState {
pub _base: root::RED4ext::IGameState,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CInitializationState"]
[::std::mem::size_of::<CInitializationState>() - 8usize];
["Alignment of CInitializationState"]
[::std::mem::align_of::<CInitializationState>() - 8usize];
};
impl Default for CInitializationState {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRunningState {
pub _base: root::RED4ext::IGameState,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRunningState"][::std::mem::size_of::<CRunningState>() - 8usize];
["Alignment of CRunningState"][::std::mem::align_of::<CRunningState>() - 8usize];
};
impl Default for CRunningState {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CShutdownState {
pub _base: root::RED4ext::IGameState,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CShutdownState"][::std::mem::size_of::<CShutdownState>() - 8usize];
["Alignment of CShutdownState"][::std::mem::align_of::<CShutdownState>() - 8usize];
};
impl Default for CShutdownState {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
unsafe extern "C" {
#[link_name = "\u{1}?CRC32Table@RED4ext@@3QBIB"]
pub static CRC32Table: [u32; 256usize];
}
unsafe extern "C" {
#[link_name = "\u{1}?Murmur3_32@RED4ext@@YAIPEBDI@Z"]
pub fn Murmur3_32(aText: *const ::std::os::raw::c_char, aSeed: u32) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?Murmur3_32@RED4ext@@YAIPEBE_KI@Z"]
pub fn Murmur3_321(aKey: *const u8, aLength: usize, aSeed: u32) -> u32;
}
#[repr(C)]
#[derive(Debug)]
pub struct UniquePtr<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub instance: *mut T,
}
impl<T> Default for UniquePtr<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
pub struct BaseStream__bindgen_vtable {
pub BaseStream_GetAllocator:
unsafe extern "C" fn(
this: *mut BaseStream,
)
-> *mut root::RED4ext::Memory::EngineAllocator,
pub BaseStream_ReadWrite: unsafe extern "C" fn(
this: *mut BaseStream,
aBuffer: *mut ::std::os::raw::c_void,
aLength: u32,
)
-> *mut ::std::os::raw::c_void,
pub BaseStream_GetPointerPosition: unsafe extern "C" fn(this: *mut BaseStream) -> usize,
pub BaseStream_GetLength: unsafe extern "C" fn(this: *mut BaseStream) -> usize,
pub BaseStream_Seek:
unsafe extern "C" fn(this: *mut BaseStream, aDistance: usize) -> bool,
pub BaseStream_Flush: unsafe extern "C" fn(this: *mut BaseStream) -> bool,
pub BaseStream_sub_38: unsafe extern "C" fn(this: *mut BaseStream),
pub BaseStream_GetFileName:
unsafe extern "C" fn(this: *mut BaseStream) -> *const ::std::os::raw::c_char,
}
#[repr(C)]
#[derive(Debug)]
pub struct BaseStream {
pub vtable_: *const BaseStream__bindgen_vtable,
pub flags: i32,
pub unkC: i32,
pub unk10: i64,
pub unk18: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of BaseStream"][::std::mem::size_of::<BaseStream>() - 32usize];
["Alignment of BaseStream"][::std::mem::align_of::<BaseStream>() - 8usize];
["Offset of field: BaseStream::flags"]
[::std::mem::offset_of!(BaseStream, flags) - 8usize];
["Offset of field: BaseStream::unkC"]
[::std::mem::offset_of!(BaseStream, unkC) - 12usize];
["Offset of field: BaseStream::unk10"]
[::std::mem::offset_of!(BaseStream, unk10) - 16usize];
["Offset of field: BaseStream::unk18"]
[::std::mem::offset_of!(BaseStream, unk18) - 24usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0BaseStream@RED4ext@@QEAA@H@Z"]
pub fn BaseStream_BaseStream(this: *mut root::RED4ext::BaseStream, aFlags: i32);
}
impl Default for BaseStream {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl BaseStream {
#[inline]
pub unsafe fn new(aFlags: i32) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
BaseStream_BaseStream(__bindgen_tmp.as_mut_ptr(), aFlags);
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}?GetAllocator@BaseStream@RED4ext@@UEAAPEAUEngineAllocator@Memory@2@XZ"]
pub fn BaseStream_GetAllocator(
this: *mut ::std::os::raw::c_void,
) -> *mut root::RED4ext::Memory::EngineAllocator;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_38@BaseStream@RED4ext@@UEAAXXZ"]
pub fn BaseStream_sub_38(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?GetFileName@BaseStream@RED4ext@@UEAAPEBDXZ"]
pub fn BaseStream_GetFileName(
this: *mut ::std::os::raw::c_void,
) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct PostLoadParams {
pub disablePreInitialization: bool,
pub pad01: [u8; 7usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of PostLoadParams"][::std::mem::size_of::<PostLoadParams>() - 8usize];
["Alignment of PostLoadParams"][::std::mem::align_of::<PostLoadParams>() - 1usize];
["Offset of field: PostLoadParams::disablePreInitialization"]
[::std::mem::offset_of!(PostLoadParams, disablePreInitialization) - 0usize];
["Offset of field: PostLoadParams::pad01"]
[::std::mem::offset_of!(PostLoadParams, pad01) - 1usize];
};
#[repr(C)]
pub struct ISerializable__bindgen_vtable {
pub ISerializable_GetNativeType:
unsafe extern "C" fn(this: *mut ISerializable) -> *mut root::RED4ext::CClass,
pub ISerializable_GetType:
unsafe extern "C" fn(this: *mut ISerializable) -> *mut root::RED4ext::CClass,
pub ISerializable_GetAllocator:
unsafe extern "C" fn(
this: *mut ISerializable,
) -> *mut root::RED4ext::Memory::IAllocator,
pub ISerializable_sub_20: unsafe extern "C" fn(this: *mut ISerializable),
pub ISerializable_PostLoad: unsafe extern "C" fn(
this: *mut ISerializable,
aParams: *const root::RED4ext::PostLoadParams,
),
pub ISerializable_sub_30: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_38: unsafe extern "C" fn(this: *mut ISerializable),
pub ISerializable_sub_40: unsafe extern "C" fn(
this: *mut ISerializable,
aStream: *mut root::RED4ext::BaseStream,
) -> bool,
pub ISerializable_sub_48:
unsafe extern "C" fn(this: *mut ISerializable, a1: i64) -> bool,
pub ISerializable_sub_50:
unsafe extern "C" fn(this: *mut ISerializable, a1: i64) -> bool,
pub ISerializable_sub_58: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_60: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_68: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_70: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_78: unsafe extern "C" fn(
this: *mut ISerializable,
a1: i64,
a2: i64,
a3: u8,
a4: i64,
a5: i64,
) -> i64,
pub ISerializable_sub_80: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_88: unsafe extern "C" fn(this: *mut ISerializable),
pub ISerializable_sub_90: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_98: unsafe extern "C" fn(this: *mut ISerializable) -> bool,
pub ISerializable_sub_A0:
unsafe extern "C" fn(this: *mut ISerializable) -> *mut ::std::os::raw::c_void,
pub ISerializable_sub_A8:
unsafe extern "C" fn(this: *mut ISerializable) -> *mut root::RED4ext::CClass,
pub ISerializable_sub_B0:
unsafe extern "C" fn(this: *mut ISerializable, a1: *mut ::std::os::raw::c_void),
pub ISerializable_sub_B8:
unsafe extern "C" fn(this: *mut ISerializable) -> root::RED4ext::CString,
pub ISerializable_sub_C0: unsafe extern "C" fn(
this: *mut ISerializable,
a1: *mut ::std::os::raw::c_void,
)
-> *mut ::std::os::raw::c_void,
pub ISerializable_sub_C8: unsafe extern "C" fn(
this: *mut ISerializable,
a1: *mut ::std::os::raw::c_void,
)
-> *mut ::std::os::raw::c_void,
pub ISerializable_CanBeDestructed:
unsafe extern "C" fn(this: *mut ISerializable) -> bool,
}
#[repr(C)]
#[derive(Debug)]
pub struct ISerializable {
pub vtable_: *const ISerializable__bindgen_vtable,
pub ref_: root::RED4ext::WeakHandle<root::RED4ext::ISerializable>,
pub unk18: root::RED4ext::WeakHandle<root::RED4ext::ISerializable>,
pub unk28: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ISerializable"][::std::mem::size_of::<ISerializable>() - 48usize];
["Alignment of ISerializable"][::std::mem::align_of::<ISerializable>() - 8usize];
["Offset of field: ISerializable::ref_"]
[::std::mem::offset_of!(ISerializable, ref_) - 8usize];
["Offset of field: ISerializable::unk18"]
[::std::mem::offset_of!(ISerializable, unk18) - 24usize];
["Offset of field: ISerializable::unk28"]
[::std::mem::offset_of!(ISerializable, unk28) - 40usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0ISerializable@RED4ext@@QEAA@XZ"]
pub fn ISerializable_ISerializable(this: *mut root::RED4ext::ISerializable);
}
impl Default for ISerializable {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl ISerializable {
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
ISerializable_ISerializable(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}?GetType@ISerializable@RED4ext@@UEAAPEAUCClass@2@XZ"]
pub fn ISerializable_GetType(
this: *mut ::std::os::raw::c_void,
) -> *mut root::RED4ext::CClass;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetAllocator@ISerializable@RED4ext@@UEAAPEAUIAllocator@Memory@2@XZ"]
pub fn ISerializable_GetAllocator(
this: *mut ::std::os::raw::c_void,
) -> *mut root::RED4ext::Memory::IAllocator;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_20@ISerializable@RED4ext@@UEAAXXZ"]
pub fn ISerializable_sub_20(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?PostLoad@ISerializable@RED4ext@@UEAAXAEBUPostLoadParams@2@@Z"]
pub fn ISerializable_PostLoad(
this: *mut ::std::os::raw::c_void,
aParams: *const root::RED4ext::PostLoadParams,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_30@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_30(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_38@ISerializable@RED4ext@@UEAAXXZ"]
pub fn ISerializable_sub_38(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_40@ISerializable@RED4ext@@UEAA_NPEAUBaseStream@2@@Z"]
pub fn ISerializable_sub_40(
this: *mut ::std::os::raw::c_void,
aStream: *mut root::RED4ext::BaseStream,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_48@ISerializable@RED4ext@@UEAA_N_J@Z"]
pub fn ISerializable_sub_48(this: *mut ::std::os::raw::c_void, a1: i64) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_50@ISerializable@RED4ext@@UEAA_N_J@Z"]
pub fn ISerializable_sub_50(this: *mut ::std::os::raw::c_void, a1: i64) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_58@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_58(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_60@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_60(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_68@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_68(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_70@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_70(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_78@ISerializable@RED4ext@@UEAA_J_J0E00@Z"]
pub fn ISerializable_sub_78(
this: *mut ::std::os::raw::c_void,
a1: i64,
a2: i64,
a3: u8,
a4: i64,
a5: i64,
) -> i64;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_80@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_80(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_88@ISerializable@RED4ext@@UEAAXXZ"]
pub fn ISerializable_sub_88(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_90@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_90(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_98@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_sub_98(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_A0@ISerializable@RED4ext@@UEAAPEAXXZ"]
pub fn ISerializable_sub_A0(
this: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_A8@ISerializable@RED4ext@@UEAAPEAUCClass@2@XZ"]
pub fn ISerializable_sub_A8(
this: *mut ::std::os::raw::c_void,
) -> *mut root::RED4ext::CClass;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_B0@ISerializable@RED4ext@@UEAAXPEAX@Z"]
pub fn ISerializable_sub_B0(
this: *mut ::std::os::raw::c_void,
a1: *mut ::std::os::raw::c_void,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_B8@ISerializable@RED4ext@@UEAA?AUCString@2@XZ"]
pub fn ISerializable_sub_B8(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::CString;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_C0@ISerializable@RED4ext@@UEAAPEAXPEAX@Z"]
pub fn ISerializable_sub_C0(
this: *mut ::std::os::raw::c_void,
a1: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_C8@ISerializable@RED4ext@@UEAAPEAXPEAX@Z"]
pub fn ISerializable_sub_C8(
this: *mut ::std::os::raw::c_void,
a1: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
#[link_name = "\u{1}?CanBeDestructed@ISerializable@RED4ext@@UEAA_NXZ"]
pub fn ISerializable_CanBeDestructed(this: *mut ::std::os::raw::c_void) -> bool;
}
pub const DefaultFixedCallbackBufferSize: usize = 32;
pub const DefaultFlexCallbackBufferSize: usize = 24;
#[repr(C)]
#[derive(Copy, Clone)]
pub union ScriptInstanceUnion {
pub const_ptr: *const ::std::os::raw::c_void,
pub ptr: *mut ::std::os::raw::c_void,
pub const_u8: *const u8,
pub u8_: *mut u8,
pub const_i8: *const i8,
pub i8_: *mut i8,
pub const_u16: *const u16,
pub u16_: *mut u16,
pub const_i16: *const i16,
pub i16_: *mut i16,
pub const_u32: *const u32,
pub u32_: *mut u32,
pub const_i32: *const i32,
pub i32_: *mut i32,
pub const_u64: *const u64,
pub u64_: *mut u64,
pub const_i64: *const i64,
pub i64_: *mut i64,
pub const_str: *const root::RED4ext::CString,
pub str_: *mut root::RED4ext::CString,
pub const_tdbid: *const root::RED4ext::TweakDBID,
pub tdbid: *mut root::RED4ext::TweakDBID,
pub const_itemid: *const root::RED4ext::ItemID,
pub itemid: *mut root::RED4ext::ItemID,
pub const_serializable: *const root::RED4ext::ISerializable,
pub serializable: *mut root::RED4ext::ISerializable,
pub const_scriptable: *const root::RED4ext::IScriptable,
pub scriptable: *mut root::RED4ext::IScriptable,
pub const_ref: *const root::RED4ext::Handle<root::RED4ext::IScriptable>,
pub ref_: *mut root::RED4ext::Handle<root::RED4ext::IScriptable>,
pub const_wref: *const root::RED4ext::WeakHandle<root::RED4ext::IScriptable>,
pub wref: *mut root::RED4ext::WeakHandle<root::RED4ext::IScriptable>,
pub const_array: *const root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub array: *mut root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub const_array_ref:
*const root::RED4ext::DynArray<root::RED4ext::Handle<root::RED4ext::IScriptable>>,
pub array_ref:
*mut root::RED4ext::DynArray<root::RED4ext::Handle<root::RED4ext::IScriptable>>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ScriptInstanceUnion"][::std::mem::size_of::<ScriptInstanceUnion>() - 8usize];
["Alignment of ScriptInstanceUnion"]
[::std::mem::align_of::<ScriptInstanceUnion>() - 8usize];
["Offset of field: ScriptInstanceUnion::const_ptr"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_ptr) - 0usize];
["Offset of field: ScriptInstanceUnion::ptr"]
[::std::mem::offset_of!(ScriptInstanceUnion, ptr) - 0usize];
["Offset of field: ScriptInstanceUnion::const_u8"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_u8) - 0usize];
["Offset of field: ScriptInstanceUnion::u8_"]
[::std::mem::offset_of!(ScriptInstanceUnion, u8_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_i8"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_i8) - 0usize];
["Offset of field: ScriptInstanceUnion::i8_"]
[::std::mem::offset_of!(ScriptInstanceUnion, i8_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_u16"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_u16) - 0usize];
["Offset of field: ScriptInstanceUnion::u16_"]
[::std::mem::offset_of!(ScriptInstanceUnion, u16_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_i16"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_i16) - 0usize];
["Offset of field: ScriptInstanceUnion::i16_"]
[::std::mem::offset_of!(ScriptInstanceUnion, i16_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_u32"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_u32) - 0usize];
["Offset of field: ScriptInstanceUnion::u32_"]
[::std::mem::offset_of!(ScriptInstanceUnion, u32_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_i32"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_i32) - 0usize];
["Offset of field: ScriptInstanceUnion::i32_"]
[::std::mem::offset_of!(ScriptInstanceUnion, i32_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_u64"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_u64) - 0usize];
["Offset of field: ScriptInstanceUnion::u64_"]
[::std::mem::offset_of!(ScriptInstanceUnion, u64_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_i64"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_i64) - 0usize];
["Offset of field: ScriptInstanceUnion::i64_"]
[::std::mem::offset_of!(ScriptInstanceUnion, i64_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_str"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_str) - 0usize];
["Offset of field: ScriptInstanceUnion::str_"]
[::std::mem::offset_of!(ScriptInstanceUnion, str_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_tdbid"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_tdbid) - 0usize];
["Offset of field: ScriptInstanceUnion::tdbid"]
[::std::mem::offset_of!(ScriptInstanceUnion, tdbid) - 0usize];
["Offset of field: ScriptInstanceUnion::const_itemid"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_itemid) - 0usize];
["Offset of field: ScriptInstanceUnion::itemid"]
[::std::mem::offset_of!(ScriptInstanceUnion, itemid) - 0usize];
["Offset of field: ScriptInstanceUnion::const_serializable"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_serializable) - 0usize];
["Offset of field: ScriptInstanceUnion::serializable"]
[::std::mem::offset_of!(ScriptInstanceUnion, serializable) - 0usize];
["Offset of field: ScriptInstanceUnion::const_scriptable"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_scriptable) - 0usize];
["Offset of field: ScriptInstanceUnion::scriptable"]
[::std::mem::offset_of!(ScriptInstanceUnion, scriptable) - 0usize];
["Offset of field: ScriptInstanceUnion::const_ref"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_ref) - 0usize];
["Offset of field: ScriptInstanceUnion::ref_"]
[::std::mem::offset_of!(ScriptInstanceUnion, ref_) - 0usize];
["Offset of field: ScriptInstanceUnion::const_wref"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_wref) - 0usize];
["Offset of field: ScriptInstanceUnion::wref"]
[::std::mem::offset_of!(ScriptInstanceUnion, wref) - 0usize];
["Offset of field: ScriptInstanceUnion::const_array"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_array) - 0usize];
["Offset of field: ScriptInstanceUnion::array"]
[::std::mem::offset_of!(ScriptInstanceUnion, array) - 0usize];
["Offset of field: ScriptInstanceUnion::const_array_ref"]
[::std::mem::offset_of!(ScriptInstanceUnion, const_array_ref) - 0usize];
["Offset of field: ScriptInstanceUnion::array_ref"]
[::std::mem::offset_of!(ScriptInstanceUnion, array_ref) - 0usize];
};
impl Default for ScriptInstanceUnion {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type ScriptInstance = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug)]
pub struct Map<K, T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub keys: root::RED4ext::DynArray<K>,
pub values: root::RED4ext::DynArray<T>,
pub flags: i32,
}
pub mod Map_Flags {
pub type Type = i32;
pub const NotSorted: Type = 0;
}
impl<K, T> Default for Map<K, T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type MapVoid =
root::RED4ext::Map<*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void>;
pub mod ERTTIType {
pub type Type = u8;
pub const Name: Type = 0;
pub const Fundamental: Type = 1;
pub const Class: Type = 2;
pub const Array: Type = 3;
pub const Simple: Type = 4;
pub const Enum: Type = 5;
pub const StaticArray: Type = 6;
pub const NativeArray: Type = 7;
pub const Pointer: Type = 8;
pub const Handle: Type = 9;
pub const WeakHandle: Type = 10;
pub const ResourceReference: Type = 11;
pub const ResourceAsyncReference: Type = 12;
pub const BitField: Type = 13;
pub const LegacySingleChannelCurve: Type = 14;
pub const ScriptReference: Type = 15;
pub const FixedArray: Type = 16;
}
#[repr(C)]
pub struct CBaseRTTIType__bindgen_vtable {
pub CBaseRTTIType_GetName:
unsafe extern "C" fn(this: *const CBaseRTTIType) -> root::RED4ext::CName,
pub CBaseRTTIType_GetSize: unsafe extern "C" fn(this: *const CBaseRTTIType) -> u32,
pub CBaseRTTIType_GetAlignment: unsafe extern "C" fn(this: *const CBaseRTTIType) -> u32,
pub CBaseRTTIType_GetType:
unsafe extern "C" fn(this: *const CBaseRTTIType) -> root::RED4ext::ERTTIType::Type,
pub CBaseRTTIType_GetTypeName:
unsafe extern "C" fn(this: *const CBaseRTTIType) -> root::RED4ext::CString,
pub CBaseRTTIType_GetComputedName:
unsafe extern "C" fn(this: *const CBaseRTTIType) -> root::RED4ext::CName,
pub CBaseRTTIType_Construct: unsafe extern "C" fn(
this: *const CBaseRTTIType,
aMemory: root::RED4ext::ScriptInstance,
),
pub CBaseRTTIType_Destruct: unsafe extern "C" fn(
this: *const CBaseRTTIType,
aMemory: root::RED4ext::ScriptInstance,
),
pub CBaseRTTIType_IsEqual: unsafe extern "C" fn(
this: *mut CBaseRTTIType,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
a3: u32,
) -> bool,
pub CBaseRTTIType_Assign: unsafe extern "C" fn(
this: *const CBaseRTTIType,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
),
pub CBaseRTTIType_Move: unsafe extern "C" fn(
this: *const CBaseRTTIType,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
),
pub CBaseRTTIType_Unserialize: unsafe extern "C" fn(
this: *const CBaseRTTIType,
aStream: *mut root::RED4ext::BaseStream,
aInstance: root::RED4ext::ScriptInstance,
a3: i64,
) -> bool,
pub CBaseRTTIType_ToString: unsafe extern "C" fn(
this: *const CBaseRTTIType,
aInstance: root::RED4ext::ScriptInstance,
aOut: *mut root::RED4ext::CString,
) -> bool,
pub CBaseRTTIType_FromString: unsafe extern "C" fn(
this: *const CBaseRTTIType,
aInstance: root::RED4ext::ScriptInstance,
aString: *const root::RED4ext::CString,
) -> bool,
pub CBaseRTTIType_sub_78: unsafe extern "C" fn(this: *mut CBaseRTTIType) -> bool,
pub CBaseRTTIType_sub_80: unsafe extern "C" fn(
this: *mut CBaseRTTIType,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
) -> bool,
pub CBaseRTTIType_sub_88: unsafe extern "C" fn(
this: *mut CBaseRTTIType,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
) -> bool,
pub CBaseRTTIType_sub_90: unsafe extern "C" fn(
this: *mut CBaseRTTIType,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
a3: *mut root::RED4ext::CString,
a4: i64,
) -> bool,
pub CBaseRTTIType_sub_98: unsafe extern "C" fn(
this: *mut CBaseRTTIType,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
a3: *mut root::RED4ext::CString,
a4: i64,
a5: bool,
) -> bool,
pub CBaseRTTIType_sub_A0: unsafe extern "C" fn(
this: *mut CBaseRTTIType,
a1: i64,
a2: *mut root::RED4ext::CString,
a3: bool,
) -> bool,
pub CBaseRTTIType_sub_A8: unsafe extern "C" fn(this: *mut CBaseRTTIType) -> bool,
pub CBaseRTTIType_sub_B0:
unsafe extern "C" fn(this: *mut CBaseRTTIType, a1: i64, a2: i64),
pub CBaseRTTIType_GetAllocator:
unsafe extern "C" fn(
this: *const CBaseRTTIType,
) -> *mut root::RED4ext::Memory::IAllocator,
}
#[repr(C)]
#[derive(Debug)]
pub struct CBaseRTTIType {
pub vtable_: *const CBaseRTTIType__bindgen_vtable,
pub unk8: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseRTTIType"][::std::mem::size_of::<CBaseRTTIType>() - 16usize];
["Alignment of CBaseRTTIType"][::std::mem::align_of::<CBaseRTTIType>() - 8usize];
["Offset of field: CBaseRTTIType::unk8"]
[::std::mem::offset_of!(CBaseRTTIType, unk8) - 8usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0CBaseRTTIType@RED4ext@@QEAA@XZ"]
pub fn CBaseRTTIType_CBaseRTTIType(this: *mut root::RED4ext::CBaseRTTIType);
}
impl Default for CBaseRTTIType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CBaseRTTIType {
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CBaseRTTIType_CBaseRTTIType(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}?GetTypeName@CBaseRTTIType@RED4ext@@UEBA?AUCString@2@XZ"]
pub fn CBaseRTTIType_GetTypeName(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::CString;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetComputedName@CBaseRTTIType@RED4ext@@UEBA?AUCName@2@XZ"]
pub fn CBaseRTTIType_GetComputedName(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?Move@CBaseRTTIType@RED4ext@@UEBAXPEAX0@Z"]
pub fn CBaseRTTIType_Move(
this: *mut ::std::os::raw::c_void,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?ToString@CBaseRTTIType@RED4ext@@UEBA_NQEAXAEAUCString@2@@Z"]
pub fn CBaseRTTIType_ToString(
this: *mut ::std::os::raw::c_void,
aInstance: root::RED4ext::ScriptInstance,
aOut: *mut root::RED4ext::CString,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?FromString@CBaseRTTIType@RED4ext@@UEBA_NPEAXAEBUCString@2@@Z"]
pub fn CBaseRTTIType_FromString(
this: *mut ::std::os::raw::c_void,
aInstance: root::RED4ext::ScriptInstance,
aString: *const root::RED4ext::CString,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_78@CBaseRTTIType@RED4ext@@UEAA_NXZ"]
pub fn CBaseRTTIType_sub_78(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_80@CBaseRTTIType@RED4ext@@UEAA_N_JPEAX@Z"]
pub fn CBaseRTTIType_sub_80(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_88@CBaseRTTIType@RED4ext@@UEAA_N_JPEAX@Z"]
pub fn CBaseRTTIType_sub_88(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_90@CBaseRTTIType@RED4ext@@UEAA_N_JPEAXAEAUCString@2@0@Z"]
pub fn CBaseRTTIType_sub_90(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
a3: *mut root::RED4ext::CString,
a4: i64,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_98@CBaseRTTIType@RED4ext@@UEAA_N_JPEAXAEAUCString@2@0_N@Z"]
pub fn CBaseRTTIType_sub_98(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
a3: *mut root::RED4ext::CString,
a4: i64,
a5: bool,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_A0@CBaseRTTIType@RED4ext@@UEAA_N_JAEAUCString@2@_N@Z"]
pub fn CBaseRTTIType_sub_A0(
this: *mut ::std::os::raw::c_void,
a1: i64,
a2: *mut root::RED4ext::CString,
a3: bool,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_A8@CBaseRTTIType@RED4ext@@UEAA_NXZ"]
pub fn CBaseRTTIType_sub_A8(this: *mut ::std::os::raw::c_void) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_B0@CBaseRTTIType@RED4ext@@UEAAX_J0@Z"]
pub fn CBaseRTTIType_sub_B0(this: *mut ::std::os::raw::c_void, a1: i64, a2: i64);
}
unsafe extern "C" {
#[link_name = "\u{1}?GetAllocator@CBaseRTTIType@RED4ext@@UEBAPEAUIAllocator@Memory@2@XZ"]
pub fn CBaseRTTIType_GetAllocator(
this: *mut ::std::os::raw::c_void,
) -> *mut root::RED4ext::Memory::IAllocator;
}
#[repr(C)]
#[derive(Debug)]
pub struct CClass {
pub _base: root::RED4ext::CBaseRTTIType,
pub parent: *mut root::RED4ext::CClass,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
pub props: root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
pub overriddenProps: root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
pub funcs: root::RED4ext::DynArray<*mut root::RED4ext::CClassFunction>,
pub staticFuncs: root::RED4ext::DynArray<*mut root::RED4ext::CClassStaticFunction>,
pub size: u32,
pub holderSize: u32,
pub flags: root::RED4ext::CClass_Flags,
pub alignment: u32,
pub funcsByName:
root::RED4ext::HashMap<root::RED4ext::CName, *mut root::RED4ext::CClassFunction>,
pub unkA8:
root::RED4ext::HashMap<*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void>,
pub unkD8: i64,
pub unkE0: i64,
pub propsByName:
root::RED4ext::HashMap<root::RED4ext::CName, *mut root::RED4ext::CProperty>,
pub unk118: root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
pub unk128: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub unk138: root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
pub unk148: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub defaults: root::RED4ext::Map<root::RED4ext::CName, *mut root::RED4ext::Variant>,
pub unk180:
root::RED4ext::HashMap<*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void>,
pub listeners: root::RED4ext::DynArray<root::RED4ext::CClass_Listener>,
pub listening: [i8; 256usize],
pub eventTypeId: i16,
pub unk2C4: i32,
pub unk2C8: root::RED4ext::SharedSpinLock,
pub unk2C9: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CClass_Flags {
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: root::__BindgenBitfieldUnit<[u8; 4usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CClass_Flags"][::std::mem::size_of::<CClass_Flags>() - 4usize];
["Alignment of CClass_Flags"][::std::mem::align_of::<CClass_Flags>() - 4usize];
};
impl CClass_Flags {
#[inline]
pub fn isAbstract(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_isAbstract(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isAbstract_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isAbstract_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isNative(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_isNative(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isNative_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
1usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isNative_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isScriptedClass(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_isScriptedClass(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isScriptedClass_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
2usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isScriptedClass_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
2usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isScriptedStruct(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
}
#[inline]
pub fn set_isScriptedStruct(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isScriptedStruct_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
3usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isScriptedStruct_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
3usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn hasNoDefaultObjectSerialization(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
}
#[inline]
pub fn set_hasNoDefaultObjectSerialization(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn hasNoDefaultObjectSerialization_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
4usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_hasNoDefaultObjectSerialization_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
4usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isAlwaysTransient(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
}
#[inline]
pub fn set_isAlwaysTransient(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isAlwaysTransient_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
5usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isAlwaysTransient_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
5usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isImportOnly(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
}
#[inline]
pub fn set_isImportOnly(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isImportOnly_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
6usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isImportOnly_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
6usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isPrivate(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
}
#[inline]
pub fn set_isPrivate(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isPrivate_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
7usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isPrivate_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
7usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isProtected(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
}
#[inline]
pub fn set_isProtected(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isProtected_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
8usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isProtected_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
8usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isTestOnly(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
}
#[inline]
pub fn set_isTestOnly(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isTestOnly_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
9usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isTestOnly_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
9usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isSavable(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
}
#[inline]
pub fn set_isSavable(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isSavable_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
10usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isSavable_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
10usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b10(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_b10(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub unsafe fn b10_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
11usize,
21u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_b10_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
11usize,
21u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
isAbstract: u32,
isNative: u32,
isScriptedClass: u32,
isScriptedStruct: u32,
hasNoDefaultObjectSerialization: u32,
isAlwaysTransient: u32,
isImportOnly: u32,
isPrivate: u32,
isProtected: u32,
isTestOnly: u32,
isSavable: u32,
b10: u32,
) -> root::__BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: root::__BindgenBitfieldUnit<[u8; 4usize]> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let isAbstract: u32 = unsafe { ::std::mem::transmute(isAbstract) };
isAbstract as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let isNative: u32 = unsafe { ::std::mem::transmute(isNative) };
isNative as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let isScriptedClass: u32 = unsafe { ::std::mem::transmute(isScriptedClass) };
isScriptedClass as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let isScriptedStruct: u32 = unsafe { ::std::mem::transmute(isScriptedStruct) };
isScriptedStruct as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let hasNoDefaultObjectSerialization: u32 =
unsafe { ::std::mem::transmute(hasNoDefaultObjectSerialization) };
hasNoDefaultObjectSerialization as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let isAlwaysTransient: u32 =
unsafe { ::std::mem::transmute(isAlwaysTransient) };
isAlwaysTransient as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let isImportOnly: u32 = unsafe { ::std::mem::transmute(isImportOnly) };
isImportOnly as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let isPrivate: u32 = unsafe { ::std::mem::transmute(isPrivate) };
isPrivate as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let isProtected: u32 = unsafe { ::std::mem::transmute(isProtected) };
isProtected as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let isTestOnly: u32 = unsafe { ::std::mem::transmute(isTestOnly) };
isTestOnly as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let isSavable: u32 = unsafe { ::std::mem::transmute(isSavable) };
isSavable as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let b10: u32 = unsafe { ::std::mem::transmute(b10) };
b10 as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CClass_Listener {
pub callback: root::__BindgenOpaqueArray<u64, 3usize>,
pub callbackName: root::RED4ext::CName,
pub eventTypeId: i16,
pub isScripted: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CClass_Listener"][::std::mem::size_of::<CClass_Listener>() - 40usize];
["Alignment of CClass_Listener"][::std::mem::align_of::<CClass_Listener>() - 8usize];
["Offset of field: CClass_Listener::callback"]
[::std::mem::offset_of!(CClass_Listener, callback) - 0usize];
["Offset of field: CClass_Listener::callbackName"]
[::std::mem::offset_of!(CClass_Listener, callbackName) - 24usize];
["Offset of field: CClass_Listener::eventTypeId"]
[::std::mem::offset_of!(CClass_Listener, eventTypeId) - 32usize];
["Offset of field: CClass_Listener::isScripted"]
[::std::mem::offset_of!(CClass_Listener, isScripted) - 34usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CClass"][::std::mem::size_of::<CClass>() - 720usize];
["Alignment of CClass"][::std::mem::align_of::<CClass>() - 8usize];
["Offset of field: CClass::parent"][::std::mem::offset_of!(CClass, parent) - 16usize];
["Offset of field: CClass::name"][::std::mem::offset_of!(CClass, name) - 24usize];
["Offset of field: CClass::computedName"]
[::std::mem::offset_of!(CClass, computedName) - 32usize];
["Offset of field: CClass::props"][::std::mem::offset_of!(CClass, props) - 40usize];
["Offset of field: CClass::overriddenProps"]
[::std::mem::offset_of!(CClass, overriddenProps) - 56usize];
["Offset of field: CClass::funcs"][::std::mem::offset_of!(CClass, funcs) - 72usize];
["Offset of field: CClass::staticFuncs"]
[::std::mem::offset_of!(CClass, staticFuncs) - 88usize];
["Offset of field: CClass::size"][::std::mem::offset_of!(CClass, size) - 104usize];
["Offset of field: CClass::holderSize"]
[::std::mem::offset_of!(CClass, holderSize) - 108usize];
["Offset of field: CClass::flags"][::std::mem::offset_of!(CClass, flags) - 112usize];
["Offset of field: CClass::alignment"]
[::std::mem::offset_of!(CClass, alignment) - 116usize];
["Offset of field: CClass::funcsByName"]
[::std::mem::offset_of!(CClass, funcsByName) - 120usize];
["Offset of field: CClass::unkA8"][::std::mem::offset_of!(CClass, unkA8) - 168usize];
["Offset of field: CClass::unkD8"][::std::mem::offset_of!(CClass, unkD8) - 216usize];
["Offset of field: CClass::unkE0"][::std::mem::offset_of!(CClass, unkE0) - 224usize];
["Offset of field: CClass::propsByName"]
[::std::mem::offset_of!(CClass, propsByName) - 232usize];
["Offset of field: CClass::unk118"][::std::mem::offset_of!(CClass, unk118) - 280usize];
["Offset of field: CClass::unk128"][::std::mem::offset_of!(CClass, unk128) - 296usize];
["Offset of field: CClass::unk138"][::std::mem::offset_of!(CClass, unk138) - 312usize];
["Offset of field: CClass::unk148"][::std::mem::offset_of!(CClass, unk148) - 328usize];
["Offset of field: CClass::defaults"]
[::std::mem::offset_of!(CClass, defaults) - 344usize];
["Offset of field: CClass::unk180"][::std::mem::offset_of!(CClass, unk180) - 384usize];
["Offset of field: CClass::listeners"]
[::std::mem::offset_of!(CClass, listeners) - 432usize];
["Offset of field: CClass::listening"]
[::std::mem::offset_of!(CClass, listening) - 448usize];
["Offset of field: CClass::eventTypeId"]
[::std::mem::offset_of!(CClass, eventTypeId) - 704usize];
["Offset of field: CClass::unk2C4"][::std::mem::offset_of!(CClass, unk2C4) - 708usize];
["Offset of field: CClass::unk2C8"][::std::mem::offset_of!(CClass, unk2C8) - 712usize];
["Offset of field: CClass::unk2C9"][::std::mem::offset_of!(CClass, unk2C9) - 713usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?CreateInstance@CClass@RED4ext@@QEBAPEAX_N@Z"]
pub fn CClass_CreateInstance(
this: *const root::RED4ext::CClass,
aZeroMemory: bool,
) -> root::RED4ext::ScriptInstance;
}
unsafe extern "C" {
#[link_name = "\u{1}?IsA@CClass@RED4ext@@QEBA_NPEBUCBaseRTTIType@2@@Z"]
pub fn CClass_IsA(
this: *const root::RED4ext::CClass,
aType: *const root::RED4ext::CBaseRTTIType,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetProperty@CClass@RED4ext@@QEAAPEAUCProperty@2@UCName@2@@Z"]
pub fn CClass_GetProperty(
this: *mut root::RED4ext::CClass,
aName: root::RED4ext::CName,
) -> *mut root::RED4ext::CProperty;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetFunction@CClass@RED4ext@@QEBAPEAUCClassFunction@2@UCName@2@@Z"]
pub fn CClass_GetFunction(
this: *const root::RED4ext::CClass,
aShortName: root::RED4ext::CName,
) -> *mut root::RED4ext::CClassFunction;
}
unsafe extern "C" {
#[link_name = "\u{1}?InitializeProperties@CClass@RED4ext@@QEAAXPEAX@Z"]
pub fn CClass_InitializeProperties(
this: *mut root::RED4ext::CClass,
aInstance: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?GetProperties@CClass@RED4ext@@QEAAXAEAU?$DynArray@PEAUCProperty@RED4ext@@@2@@Z"]
pub fn CClass_GetProperties(
this: *mut root::RED4ext::CClass,
aProps: *mut root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?RegisterFunction@CClass@RED4ext@@QEAAXPEAUCClassFunction@2@@Z"]
pub fn CClass_RegisterFunction(
this: *mut root::RED4ext::CClass,
aFunc: *mut root::RED4ext::CClassFunction,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?ClearScriptedData@CClass@RED4ext@@QEAAXXZ"]
pub fn CClass_ClearScriptedData(this: *mut root::RED4ext::CClass);
}
unsafe extern "C" {
#[link_name = "\u{1}??0CClass@RED4ext@@QEAA@UCName@1@IUFlags@01@@Z"]
pub fn CClass_CClass(
this: *mut root::RED4ext::CClass,
aName: root::RED4ext::CName,
aSize: u32,
aFlags: root::RED4ext::CClass_Flags,
);
}
impl Default for CClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CClass {
#[inline]
pub unsafe fn CreateInstance(
&self,
aZeroMemory: bool,
) -> root::RED4ext::ScriptInstance {
CClass_CreateInstance(self, aZeroMemory)
}
#[inline]
pub unsafe fn IsA(&self, aType: *const root::RED4ext::CBaseRTTIType) -> bool {
CClass_IsA(self, aType)
}
#[inline]
pub unsafe fn GetProperty(
&mut self,
aName: root::RED4ext::CName,
) -> *mut root::RED4ext::CProperty {
CClass_GetProperty(self, aName)
}
#[inline]
pub unsafe fn GetFunction(
&self,
aShortName: root::RED4ext::CName,
) -> *mut root::RED4ext::CClassFunction {
CClass_GetFunction(self, aShortName)
}
#[inline]
pub unsafe fn InitializeProperties(
&mut self,
aInstance: root::RED4ext::ScriptInstance,
) {
CClass_InitializeProperties(self, aInstance)
}
#[inline]
pub unsafe fn GetProperties(
&mut self,
aProps: *mut root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
) {
CClass_GetProperties(self, aProps)
}
#[inline]
pub unsafe fn RegisterFunction(&mut self, aFunc: *mut root::RED4ext::CClassFunction) {
CClass_RegisterFunction(self, aFunc)
}
#[inline]
pub unsafe fn ClearScriptedData(&mut self) {
CClass_ClearScriptedData(self)
}
#[inline]
pub unsafe fn new(
aName: root::RED4ext::CName,
aSize: u32,
aFlags: root::RED4ext::CClass_Flags,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CClass_CClass(__bindgen_tmp.as_mut_ptr(), aName, aSize, aFlags);
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}?GetName@CClass@RED4ext@@UEBA?AUCName@2@XZ"]
pub fn CClass_GetName(this: *mut ::std::os::raw::c_void) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetSize@CClass@RED4ext@@UEBAIXZ"]
pub fn CClass_GetSize(this: *mut ::std::os::raw::c_void) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetAlignment@CClass@RED4ext@@UEBAIXZ"]
pub fn CClass_GetAlignment(this: *mut ::std::os::raw::c_void) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetType@CClass@RED4ext@@UEBA?AW4ERTTIType@2@XZ"]
pub fn CClass_GetType(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::ERTTIType::Type;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetComputedName@CClass@RED4ext@@UEBA?AUCName@2@XZ"]
pub fn CClass_GetComputedName(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?Construct@CClass@RED4ext@@UEBAXPEAX@Z"]
pub fn CClass_Construct(
this: *mut ::std::os::raw::c_void,
aMemory: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Destruct@CClass@RED4ext@@UEBAXPEAX@Z"]
pub fn CClass_Destruct(
this: *mut ::std::os::raw::c_void,
aMemory: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Unserialize@CClass@RED4ext@@UEBA_NPEAUBaseStream@2@PEAX_J@Z"]
pub fn CClass_Unserialize(
this: *mut ::std::os::raw::c_void,
aStream: *mut root::RED4ext::BaseStream,
aInstance: root::RED4ext::ScriptInstance,
a3: i64,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ToString@CClass@RED4ext@@UEBA_NQEAXAEAUCString@2@@Z"]
pub fn CClass_ToString(
this: *mut ::std::os::raw::c_void,
aInstance: root::RED4ext::ScriptInstance,
aOut: *mut root::RED4ext::CString,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_80@CClass@RED4ext@@UEAA_N_JPEAX@Z"]
pub fn CClass_sub_80(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_88@CClass@RED4ext@@UEAA_N_JPEAX@Z"]
pub fn CClass_sub_88(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_90@CClass@RED4ext@@UEAA_N_JPEAXAEAUCString@2@0@Z"]
pub fn CClass_sub_90(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
a3: *mut root::RED4ext::CString,
a4: i64,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_98@CClass@RED4ext@@UEAA_N_JPEAXAEAUCString@2@0_N@Z"]
pub fn CClass_sub_98(
this: *mut ::std::os::raw::c_void,
a1: i64,
aInstance: root::RED4ext::ScriptInstance,
a3: *mut root::RED4ext::CString,
a4: i64,
a5: bool,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_A0@CClass@RED4ext@@UEAA_N_JAEAUCString@2@_N@Z"]
pub fn CClass_sub_A0(
this: *mut ::std::os::raw::c_void,
a1: i64,
a2: *mut root::RED4ext::CString,
a3: bool,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_B0@CClass@RED4ext@@UEAAX_J0@Z"]
pub fn CClass_sub_B0(this: *mut ::std::os::raw::c_void, a1: i64, a2: i64);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_C0@CClass@RED4ext@@UEAAXXZ"]
pub fn CClass_sub_C0(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?GetMaxAlignment@CClass@RED4ext@@UEBAIXZ"]
pub fn CClass_GetMaxAlignment(this: *mut ::std::os::raw::c_void) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_D0@CClass@RED4ext@@UEBA_NXZ"]
pub fn CClass_sub_D0(this: *mut ::std::os::raw::c_void) -> bool;
}
#[repr(C)]
#[derive(Debug)]
pub struct TTypedClass {
pub _base: root::RED4ext::CClass,
}
impl Default for TTypedClass {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CEnum {
pub _base: root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
pub actualSize: u8,
pub flags: root::RED4ext::CEnum_Flags,
pub hashList: root::RED4ext::DynArray<root::RED4ext::CName>,
pub valueList: root::RED4ext::DynArray<i64>,
pub aliasList: root::RED4ext::DynArray<root::RED4ext::CName>,
pub aliasValueList: root::RED4ext::DynArray<i64>,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CEnum_Flags {
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: root::__BindgenBitfieldUnit<[u8; 1usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CEnum_Flags"][::std::mem::size_of::<CEnum_Flags>() - 1usize];
["Alignment of CEnum_Flags"][::std::mem::align_of::<CEnum_Flags>() - 1usize];
};
impl CEnum_Flags {
#[inline]
pub fn isScripted(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_isScripted(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isScripted_raw(this: *const Self) -> u8 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
1u8,
) as u8)
}
}
#[inline]
pub unsafe fn set_isScripted_raw(this: *mut Self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b2(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
}
#[inline]
pub fn set_b2(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 7u8, val as u64)
}
}
#[inline]
pub unsafe fn b2_raw(this: *const Self) -> u8 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
1usize,
7u8,
) as u8)
}
}
#[inline]
pub unsafe fn set_b2_raw(this: *mut Self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1usize,
7u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
isScripted: u8,
b2: u8,
) -> root::__BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: root::__BindgenBitfieldUnit<[u8; 1usize]> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let isScripted: u8 = unsafe { ::std::mem::transmute(isScripted) };
isScripted as u64
});
__bindgen_bitfield_unit.set(1usize, 7u8, {
let b2: u8 = unsafe { ::std::mem::transmute(b2) };
b2 as u64
});
__bindgen_bitfield_unit
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CEnum"][::std::mem::size_of::<CEnum>() - 104usize];
["Alignment of CEnum"][::std::mem::align_of::<CEnum>() - 8usize];
["Offset of field: CEnum::name"][::std::mem::offset_of!(CEnum, name) - 16usize];
["Offset of field: CEnum::computedName"]
[::std::mem::offset_of!(CEnum, computedName) - 24usize];
["Offset of field: CEnum::actualSize"]
[::std::mem::offset_of!(CEnum, actualSize) - 32usize];
["Offset of field: CEnum::flags"][::std::mem::offset_of!(CEnum, flags) - 33usize];
["Offset of field: CEnum::hashList"][::std::mem::offset_of!(CEnum, hashList) - 40usize];
["Offset of field: CEnum::valueList"]
[::std::mem::offset_of!(CEnum, valueList) - 56usize];
["Offset of field: CEnum::aliasList"]
[::std::mem::offset_of!(CEnum, aliasList) - 72usize];
["Offset of field: CEnum::aliasValueList"]
[::std::mem::offset_of!(CEnum, aliasValueList) - 88usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0CEnum@RED4ext@@QEAA@UCName@1@CUFlags@01@@Z"]
pub fn CEnum_CEnum(
this: *mut root::RED4ext::CEnum,
aName: root::RED4ext::CName,
aActualSize: i8,
aFlags: root::RED4ext::CEnum_Flags,
);
}
impl Default for CEnum {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CEnum {
#[inline]
pub unsafe fn new(
aName: root::RED4ext::CName,
aActualSize: i8,
aFlags: root::RED4ext::CEnum_Flags,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CEnum_CEnum(__bindgen_tmp.as_mut_ptr(), aName, aActualSize, aFlags);
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}?GetName@CEnum@RED4ext@@UEBA?AUCName@2@XZ"]
pub fn CEnum_GetName(this: *mut ::std::os::raw::c_void) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetSize@CEnum@RED4ext@@UEBAIXZ"]
pub fn CEnum_GetSize(this: *mut ::std::os::raw::c_void) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetAlignment@CEnum@RED4ext@@UEBAIXZ"]
pub fn CEnum_GetAlignment(this: *mut ::std::os::raw::c_void) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetType@CEnum@RED4ext@@UEBA?AW4ERTTIType@2@XZ"]
pub fn CEnum_GetType(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::ERTTIType::Type;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetComputedName@CEnum@RED4ext@@UEBA?AUCName@2@XZ"]
pub fn CEnum_GetComputedName(this: *mut ::std::os::raw::c_void)
-> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?Construct@CEnum@RED4ext@@UEBAXPEAX@Z"]
pub fn CEnum_Construct(
this: *mut ::std::os::raw::c_void,
aMemory: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Destruct@CEnum@RED4ext@@UEBAXPEAX@Z"]
pub fn CEnum_Destruct(
this: *mut ::std::os::raw::c_void,
aMemory: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?IsEqual@CEnum@RED4ext@@UEAA?B_NQEAX0I@Z"]
pub fn CEnum_IsEqual(
this: *mut ::std::os::raw::c_void,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
a3: u32,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?Assign@CEnum@RED4ext@@UEBAXPEAXQEAX@Z"]
pub fn CEnum_Assign(
this: *mut ::std::os::raw::c_void,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Unserialize@CEnum@RED4ext@@UEBA_NPEAUBaseStream@2@PEAX_J@Z"]
pub fn CEnum_Unserialize(
this: *mut ::std::os::raw::c_void,
aStream: *mut root::RED4ext::BaseStream,
aInstance: root::RED4ext::ScriptInstance,
a3: i64,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ToString@CEnum@RED4ext@@UEBA_NQEAXAEAUCString@2@@Z"]
pub fn CEnum_ToString(
this: *mut ::std::os::raw::c_void,
aInstance: root::RED4ext::ScriptInstance,
aOut: *mut root::RED4ext::CString,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?FromString@CEnum@RED4ext@@UEBA_NPEAXAEBUCString@2@@Z"]
pub fn CEnum_FromString(
this: *mut ::std::os::raw::c_void,
aInstance: root::RED4ext::ScriptInstance,
aString: *const root::RED4ext::CString,
) -> bool;
}
#[repr(C)]
#[derive(Debug)]
pub struct CBitfield {
pub _base: root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
pub actualSize: u8,
pub flags: root::RED4ext::CBitfield_Flags,
pub validBits: u64,
pub bitNames: [root::RED4ext::CName; 64usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CBitfield_Flags {
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: root::__BindgenBitfieldUnit<[u8; 1usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBitfield_Flags"][::std::mem::size_of::<CBitfield_Flags>() - 1usize];
["Alignment of CBitfield_Flags"][::std::mem::align_of::<CBitfield_Flags>() - 1usize];
};
impl CBitfield_Flags {
#[inline]
pub fn isScripted(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_isScripted(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isScripted_raw(this: *const Self) -> u8 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
1u8,
) as u8)
}
}
#[inline]
pub unsafe fn set_isScripted_raw(this: *mut Self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b2(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
}
#[inline]
pub fn set_b2(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 7u8, val as u64)
}
}
#[inline]
pub unsafe fn b2_raw(this: *const Self) -> u8 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
1usize,
7u8,
) as u8)
}
}
#[inline]
pub unsafe fn set_b2_raw(this: *mut Self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1usize,
7u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
isScripted: u8,
b2: u8,
) -> root::__BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: root::__BindgenBitfieldUnit<[u8; 1usize]> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let isScripted: u8 = unsafe { ::std::mem::transmute(isScripted) };
isScripted as u64
});
__bindgen_bitfield_unit.set(1usize, 7u8, {
let b2: u8 = unsafe { ::std::mem::transmute(b2) };
b2 as u64
});
__bindgen_bitfield_unit
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBitfield"][::std::mem::size_of::<CBitfield>() - 560usize];
["Alignment of CBitfield"][::std::mem::align_of::<CBitfield>() - 8usize];
["Offset of field: CBitfield::name"][::std::mem::offset_of!(CBitfield, name) - 16usize];
["Offset of field: CBitfield::computedName"]
[::std::mem::offset_of!(CBitfield, computedName) - 24usize];
["Offset of field: CBitfield::actualSize"]
[::std::mem::offset_of!(CBitfield, actualSize) - 32usize];
["Offset of field: CBitfield::flags"]
[::std::mem::offset_of!(CBitfield, flags) - 33usize];
["Offset of field: CBitfield::validBits"]
[::std::mem::offset_of!(CBitfield, validBits) - 40usize];
["Offset of field: CBitfield::bitNames"]
[::std::mem::offset_of!(CBitfield, bitNames) - 48usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0CBitfield@RED4ext@@QEAA@UCName@1@CUFlags@01@@Z"]
pub fn CBitfield_CBitfield(
this: *mut root::RED4ext::CBitfield,
aName: root::RED4ext::CName,
aActualSize: i8,
aFlags: root::RED4ext::CBitfield_Flags,
);
}
impl Default for CBitfield {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CBitfield {
#[inline]
pub unsafe fn new(
aName: root::RED4ext::CName,
aActualSize: i8,
aFlags: root::RED4ext::CBitfield_Flags,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CBitfield_CBitfield(__bindgen_tmp.as_mut_ptr(), aName, aActualSize, aFlags);
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}?GetName@CBitfield@RED4ext@@UEBA?AUCName@2@XZ"]
pub fn CBitfield_GetName(this: *mut ::std::os::raw::c_void) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetSize@CBitfield@RED4ext@@UEBAIXZ"]
pub fn CBitfield_GetSize(this: *mut ::std::os::raw::c_void) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetAlignment@CBitfield@RED4ext@@UEBAIXZ"]
pub fn CBitfield_GetAlignment(this: *mut ::std::os::raw::c_void) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetType@CBitfield@RED4ext@@UEBA?AW4ERTTIType@2@XZ"]
pub fn CBitfield_GetType(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::ERTTIType::Type;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetComputedName@CBitfield@RED4ext@@UEBA?AUCName@2@XZ"]
pub fn CBitfield_GetComputedName(
this: *mut ::std::os::raw::c_void,
) -> root::RED4ext::CName;
}
unsafe extern "C" {
#[link_name = "\u{1}?Construct@CBitfield@RED4ext@@UEBAXPEAX@Z"]
pub fn CBitfield_Construct(
this: *mut ::std::os::raw::c_void,
aMemory: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Destruct@CBitfield@RED4ext@@UEBAXPEAX@Z"]
pub fn CBitfield_Destruct(
this: *mut ::std::os::raw::c_void,
aMemory: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?IsEqual@CBitfield@RED4ext@@UEAA?B_NQEAX0I@Z"]
pub fn CBitfield_IsEqual(
this: *mut ::std::os::raw::c_void,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
a3: u32,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?Assign@CBitfield@RED4ext@@UEBAXPEAXQEAX@Z"]
pub fn CBitfield_Assign(
this: *mut ::std::os::raw::c_void,
aLhs: root::RED4ext::ScriptInstance,
aRhs: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Unserialize@CBitfield@RED4ext@@UEBA_NPEAUBaseStream@2@PEAX_J@Z"]
pub fn CBitfield_Unserialize(
this: *mut ::std::os::raw::c_void,
aStream: *mut root::RED4ext::BaseStream,
aInstance: root::RED4ext::ScriptInstance,
a3: i64,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ToString@CBitfield@RED4ext@@UEBA_NQEAXAEAUCString@2@@Z"]
pub fn CBitfield_ToString(
this: *mut ::std::os::raw::c_void,
aInstance: root::RED4ext::ScriptInstance,
aOut: *mut root::RED4ext::CString,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?FromString@CBitfield@RED4ext@@UEBA_NPEAXAEBUCString@2@@Z"]
pub fn CBitfield_FromString(
this: *mut ::std::os::raw::c_void,
aInstance: root::RED4ext::ScriptInstance,
aString: *const root::RED4ext::CString,
) -> bool;
}
pub type CFundamentalRTTITypeBool = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeInt8 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeUint8 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeInt16 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeUint16 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeInt32 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeUint32 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeInt64 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeUint64 = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeFloat = root::RED4ext::CBaseRTTIType;
pub type CFundamentalRTTITypeDouble = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeCName = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeString = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeLocalizationString = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeTweakDBID = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeDataBuffer = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeSerializationDeferredDataBuffer = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeSharedDataBuffer = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeVariant = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeCDateTime = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeCGUID = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeCRUID = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeCRUIDRef = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeEditorObjectID = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeGamedataLocKeyWrapper = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeMessageResourcePath = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeNodeRef = root::RED4ext::CBaseRTTIType;
pub type CSimpleRTTITypeRuntimeEntityRef = root::RED4ext::CBaseRTTIType;
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIBaseArrayType {
pub _base: root::RED4ext::CBaseRTTIType,
pub innerType: *mut root::RED4ext::CBaseRTTIType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIBaseArrayType"][::std::mem::size_of::<CRTTIBaseArrayType>() - 24usize];
["Alignment of CRTTIBaseArrayType"]
[::std::mem::align_of::<CRTTIBaseArrayType>() - 8usize];
["Offset of field: CRTTIBaseArrayType::innerType"]
[::std::mem::offset_of!(CRTTIBaseArrayType, innerType) - 16usize];
};
impl Default for CRTTIBaseArrayType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIArrayType {
pub _base: root::RED4ext::CRTTIBaseArrayType,
pub name: root::RED4ext::CName,
pub parent: *mut root::RED4ext::CBaseRTTIType,
pub unk28: usize,
pub unk30: usize,
pub unk38: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIArrayType"][::std::mem::size_of::<CRTTIArrayType>() - 64usize];
["Alignment of CRTTIArrayType"][::std::mem::align_of::<CRTTIArrayType>() - 8usize];
["Offset of field: CRTTIArrayType::name"]
[::std::mem::offset_of!(CRTTIArrayType, name) - 24usize];
["Offset of field: CRTTIArrayType::parent"]
[::std::mem::offset_of!(CRTTIArrayType, parent) - 32usize];
["Offset of field: CRTTIArrayType::unk28"]
[::std::mem::offset_of!(CRTTIArrayType, unk28) - 40usize];
["Offset of field: CRTTIArrayType::unk30"]
[::std::mem::offset_of!(CRTTIArrayType, unk30) - 48usize];
["Offset of field: CRTTIArrayType::unk38"]
[::std::mem::offset_of!(CRTTIArrayType, unk38) - 56usize];
};
impl Default for CRTTIArrayType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIStaticArrayType {
pub _base: root::RED4ext::CRTTIBaseArrayType,
pub size: i32,
pub pad1C: u32,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIStaticArrayType"]
[::std::mem::size_of::<CRTTIStaticArrayType>() - 48usize];
["Alignment of CRTTIStaticArrayType"]
[::std::mem::align_of::<CRTTIStaticArrayType>() - 8usize];
["Offset of field: CRTTIStaticArrayType::size"]
[::std::mem::offset_of!(CRTTIStaticArrayType, size) - 24usize];
["Offset of field: CRTTIStaticArrayType::pad1C"]
[::std::mem::offset_of!(CRTTIStaticArrayType, pad1C) - 28usize];
["Offset of field: CRTTIStaticArrayType::name"]
[::std::mem::offset_of!(CRTTIStaticArrayType, name) - 32usize];
["Offset of field: CRTTIStaticArrayType::computedName"]
[::std::mem::offset_of!(CRTTIStaticArrayType, computedName) - 40usize];
};
impl Default for CRTTIStaticArrayType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTINativeArrayType {
pub _base: root::RED4ext::CRTTIBaseArrayType,
pub size: i32,
pub pad1C: u32,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTINativeArrayType"]
[::std::mem::size_of::<CRTTINativeArrayType>() - 48usize];
["Alignment of CRTTINativeArrayType"]
[::std::mem::align_of::<CRTTINativeArrayType>() - 8usize];
["Offset of field: CRTTINativeArrayType::size"]
[::std::mem::offset_of!(CRTTINativeArrayType, size) - 24usize];
["Offset of field: CRTTINativeArrayType::pad1C"]
[::std::mem::offset_of!(CRTTINativeArrayType, pad1C) - 28usize];
["Offset of field: CRTTINativeArrayType::name"]
[::std::mem::offset_of!(CRTTINativeArrayType, name) - 32usize];
["Offset of field: CRTTINativeArrayType::computedName"]
[::std::mem::offset_of!(CRTTINativeArrayType, computedName) - 40usize];
};
impl Default for CRTTINativeArrayType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIPointerType {
pub _base: root::RED4ext::CBaseRTTIType,
pub innerType: *mut root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub unk20: root::RED4ext::CName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIPointerType"][::std::mem::size_of::<CRTTIPointerType>() - 40usize];
["Alignment of CRTTIPointerType"][::std::mem::align_of::<CRTTIPointerType>() - 8usize];
["Offset of field: CRTTIPointerType::innerType"]
[::std::mem::offset_of!(CRTTIPointerType, innerType) - 16usize];
["Offset of field: CRTTIPointerType::name"]
[::std::mem::offset_of!(CRTTIPointerType, name) - 24usize];
["Offset of field: CRTTIPointerType::unk20"]
[::std::mem::offset_of!(CRTTIPointerType, unk20) - 32usize];
};
impl Default for CRTTIPointerType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIScriptReferenceType {
pub _base: root::RED4ext::CBaseRTTIType,
pub innerType: *mut root::RED4ext::CBaseRTTIType,
pub unk18: i64,
pub name: root::RED4ext::CName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIScriptReferenceType"]
[::std::mem::size_of::<CRTTIScriptReferenceType>() - 40usize];
["Alignment of CRTTIScriptReferenceType"]
[::std::mem::align_of::<CRTTIScriptReferenceType>() - 8usize];
["Offset of field: CRTTIScriptReferenceType::innerType"]
[::std::mem::offset_of!(CRTTIScriptReferenceType, innerType) - 16usize];
["Offset of field: CRTTIScriptReferenceType::unk18"]
[::std::mem::offset_of!(CRTTIScriptReferenceType, unk18) - 24usize];
["Offset of field: CRTTIScriptReferenceType::name"]
[::std::mem::offset_of!(CRTTIScriptReferenceType, name) - 32usize];
};
impl Default for CRTTIScriptReferenceType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIHandleType {
pub _base: root::RED4ext::CBaseRTTIType,
pub innerType: *mut root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIHandleType"][::std::mem::size_of::<CRTTIHandleType>() - 40usize];
["Alignment of CRTTIHandleType"][::std::mem::align_of::<CRTTIHandleType>() - 8usize];
["Offset of field: CRTTIHandleType::innerType"]
[::std::mem::offset_of!(CRTTIHandleType, innerType) - 16usize];
["Offset of field: CRTTIHandleType::name"]
[::std::mem::offset_of!(CRTTIHandleType, name) - 24usize];
["Offset of field: CRTTIHandleType::computedName"]
[::std::mem::offset_of!(CRTTIHandleType, computedName) - 32usize];
};
impl Default for CRTTIHandleType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIWeakHandleType {
pub _base: root::RED4ext::CBaseRTTIType,
pub innerType: *mut root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIWeakHandleType"][::std::mem::size_of::<CRTTIWeakHandleType>() - 40usize];
["Alignment of CRTTIWeakHandleType"]
[::std::mem::align_of::<CRTTIWeakHandleType>() - 8usize];
["Offset of field: CRTTIWeakHandleType::innerType"]
[::std::mem::offset_of!(CRTTIWeakHandleType, innerType) - 16usize];
["Offset of field: CRTTIWeakHandleType::name"]
[::std::mem::offset_of!(CRTTIWeakHandleType, name) - 24usize];
["Offset of field: CRTTIWeakHandleType::computedName"]
[::std::mem::offset_of!(CRTTIWeakHandleType, computedName) - 32usize];
};
impl Default for CRTTIWeakHandleType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIResourceReferenceType {
pub _base: root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
pub innerType: *mut root::RED4ext::CBaseRTTIType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIResourceReferenceType"]
[::std::mem::size_of::<CRTTIResourceReferenceType>() - 40usize];
["Alignment of CRTTIResourceReferenceType"]
[::std::mem::align_of::<CRTTIResourceReferenceType>() - 8usize];
["Offset of field: CRTTIResourceReferenceType::name"]
[::std::mem::offset_of!(CRTTIResourceReferenceType, name) - 16usize];
["Offset of field: CRTTIResourceReferenceType::computedName"]
[::std::mem::offset_of!(CRTTIResourceReferenceType, computedName) - 24usize];
["Offset of field: CRTTIResourceReferenceType::innerType"]
[::std::mem::offset_of!(CRTTIResourceReferenceType, innerType) - 32usize];
};
impl Default for CRTTIResourceReferenceType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIResourceAsyncReferenceType {
pub _base: root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub computedName: root::RED4ext::CName,
pub innerType: *mut root::RED4ext::CBaseRTTIType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIResourceAsyncReferenceType"]
[::std::mem::size_of::<CRTTIResourceAsyncReferenceType>() - 40usize];
["Alignment of CRTTIResourceAsyncReferenceType"]
[::std::mem::align_of::<CRTTIResourceAsyncReferenceType>() - 8usize];
["Offset of field: CRTTIResourceAsyncReferenceType::name"]
[::std::mem::offset_of!(CRTTIResourceAsyncReferenceType, name) - 16usize];
["Offset of field: CRTTIResourceAsyncReferenceType::computedName"]
[::std::mem::offset_of!(CRTTIResourceAsyncReferenceType, computedName) - 24usize];
["Offset of field: CRTTIResourceAsyncReferenceType::innerType"]
[::std::mem::offset_of!(CRTTIResourceAsyncReferenceType, innerType) - 32usize];
};
impl Default for CRTTIResourceAsyncReferenceType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTILegacySingleChannelCurveType {
pub _base: root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub unk18: u64,
pub unk20: u64,
pub unk28: u64,
pub unk30: u8,
pub unk31: u8,
pub pad32: u16,
pub pad34: u32,
pub curveType: *mut root::RED4ext::CBaseRTTIType,
pub unk40: u16,
pub pad42: u16,
pub pad44: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTILegacySingleChannelCurveType"]
[::std::mem::size_of::<CRTTILegacySingleChannelCurveType>() - 72usize];
["Alignment of CRTTILegacySingleChannelCurveType"]
[::std::mem::align_of::<CRTTILegacySingleChannelCurveType>() - 8usize];
["Offset of field: CRTTILegacySingleChannelCurveType::name"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, name) - 16usize];
["Offset of field: CRTTILegacySingleChannelCurveType::unk18"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, unk18) - 24usize];
["Offset of field: CRTTILegacySingleChannelCurveType::unk20"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, unk20) - 32usize];
["Offset of field: CRTTILegacySingleChannelCurveType::unk28"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, unk28) - 40usize];
["Offset of field: CRTTILegacySingleChannelCurveType::unk30"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, unk30) - 48usize];
["Offset of field: CRTTILegacySingleChannelCurveType::unk31"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, unk31) - 49usize];
["Offset of field: CRTTILegacySingleChannelCurveType::pad32"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, pad32) - 50usize];
["Offset of field: CRTTILegacySingleChannelCurveType::pad34"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, pad34) - 52usize];
["Offset of field: CRTTILegacySingleChannelCurveType::curveType"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, curveType) - 56usize];
["Offset of field: CRTTILegacySingleChannelCurveType::unk40"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, unk40) - 64usize];
["Offset of field: CRTTILegacySingleChannelCurveType::pad42"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, pad42) - 66usize];
["Offset of field: CRTTILegacySingleChannelCurveType::pad44"]
[::std::mem::offset_of!(CRTTILegacySingleChannelCurveType, pad44) - 68usize];
};
impl Default for CRTTILegacySingleChannelCurveType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIMultiChannelCurveType {
pub _base: root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub curveType: *mut root::RED4ext::CBaseRTTIType,
pub unk20: i64,
pub unk28: i64,
pub unk30: i64,
pub unk38: i64,
pub unk40: i32,
pub unk44: i16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIMultiChannelCurveType"]
[::std::mem::size_of::<CRTTIMultiChannelCurveType>() - 72usize];
["Alignment of CRTTIMultiChannelCurveType"]
[::std::mem::align_of::<CRTTIMultiChannelCurveType>() - 8usize];
["Offset of field: CRTTIMultiChannelCurveType::name"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, name) - 16usize];
["Offset of field: CRTTIMultiChannelCurveType::curveType"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, curveType) - 24usize];
["Offset of field: CRTTIMultiChannelCurveType::unk20"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, unk20) - 32usize];
["Offset of field: CRTTIMultiChannelCurveType::unk28"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, unk28) - 40usize];
["Offset of field: CRTTIMultiChannelCurveType::unk30"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, unk30) - 48usize];
["Offset of field: CRTTIMultiChannelCurveType::unk38"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, unk38) - 56usize];
["Offset of field: CRTTIMultiChannelCurveType::unk40"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, unk40) - 64usize];
["Offset of field: CRTTIMultiChannelCurveType::unk44"]
[::std::mem::offset_of!(CRTTIMultiChannelCurveType, unk44) - 68usize];
};
impl Default for CRTTIMultiChannelCurveType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct IRTTIType {
pub _base: root::RED4ext::CBaseRTTIType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IRTTIType"][::std::mem::size_of::<IRTTIType>() - 16usize];
["Alignment of IRTTIType"][::std::mem::align_of::<IRTTIType>() - 8usize];
};
impl Default for IRTTIType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIBaseType {
pub _base: root::RED4ext::CBaseRTTIType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIBaseType"][::std::mem::size_of::<CRTTIBaseType>() - 16usize];
["Alignment of CRTTIBaseType"][::std::mem::align_of::<CRTTIBaseType>() - 8usize];
};
impl Default for CRTTIBaseType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRTTIType {
pub _base: root::RED4ext::CBaseRTTIType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTIType"][::std::mem::size_of::<CRTTIType>() - 16usize];
["Alignment of CRTTIType"][::std::mem::align_of::<CRTTIType>() - 8usize];
};
impl Default for CRTTIType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct BoolType {
pub _base: root::RED4ext::CFundamentalRTTITypeBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of BoolType"][::std::mem::size_of::<BoolType>() - 16usize];
["Alignment of BoolType"][::std::mem::align_of::<BoolType>() - 8usize];
};
impl Default for BoolType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Int8Type {
pub _base: root::RED4ext::CFundamentalRTTITypeInt8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Int8Type"][::std::mem::size_of::<Int8Type>() - 16usize];
["Alignment of Int8Type"][::std::mem::align_of::<Int8Type>() - 8usize];
};
impl Default for Int8Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Uint8Type {
pub _base: root::RED4ext::CFundamentalRTTITypeUint8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Uint8Type"][::std::mem::size_of::<Uint8Type>() - 16usize];
["Alignment of Uint8Type"][::std::mem::align_of::<Uint8Type>() - 8usize];
};
impl Default for Uint8Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Int16Type {
pub _base: root::RED4ext::CFundamentalRTTITypeInt16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Int16Type"][::std::mem::size_of::<Int16Type>() - 16usize];
["Alignment of Int16Type"][::std::mem::align_of::<Int16Type>() - 8usize];
};
impl Default for Int16Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Uint16Type {
pub _base: root::RED4ext::CFundamentalRTTITypeUint16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Uint16Type"][::std::mem::size_of::<Uint16Type>() - 16usize];
["Alignment of Uint16Type"][::std::mem::align_of::<Uint16Type>() - 8usize];
};
impl Default for Uint16Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Int32Type {
pub _base: root::RED4ext::CFundamentalRTTITypeInt32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Int32Type"][::std::mem::size_of::<Int32Type>() - 16usize];
["Alignment of Int32Type"][::std::mem::align_of::<Int32Type>() - 8usize];
};
impl Default for Int32Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Uint32Type {
pub _base: root::RED4ext::CFundamentalRTTITypeUint32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Uint32Type"][::std::mem::size_of::<Uint32Type>() - 16usize];
["Alignment of Uint32Type"][::std::mem::align_of::<Uint32Type>() - 8usize];
};
impl Default for Uint32Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Int64Type {
pub _base: root::RED4ext::CFundamentalRTTITypeInt64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Int64Type"][::std::mem::size_of::<Int64Type>() - 16usize];
["Alignment of Int64Type"][::std::mem::align_of::<Int64Type>() - 8usize];
};
impl Default for Int64Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct Uint64Type {
pub _base: root::RED4ext::CFundamentalRTTITypeUint64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Uint64Type"][::std::mem::size_of::<Uint64Type>() - 16usize];
["Alignment of Uint64Type"][::std::mem::align_of::<Uint64Type>() - 8usize];
};
impl Default for Uint64Type {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct FloatType {
pub _base: root::RED4ext::CFundamentalRTTITypeFloat,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of FloatType"][::std::mem::size_of::<FloatType>() - 16usize];
["Alignment of FloatType"][::std::mem::align_of::<FloatType>() - 8usize];
};
impl Default for FloatType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct DoubleType {
pub _base: root::RED4ext::CFundamentalRTTITypeDouble,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of DoubleType"][::std::mem::size_of::<DoubleType>() - 16usize];
["Alignment of DoubleType"][::std::mem::align_of::<DoubleType>() - 8usize];
};
impl Default for DoubleType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CNameType {
pub _base: root::RED4ext::CSimpleRTTITypeCName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CNameType"][::std::mem::size_of::<CNameType>() - 16usize];
["Alignment of CNameType"][::std::mem::align_of::<CNameType>() - 8usize];
};
impl Default for CNameType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct StringType {
pub _base: root::RED4ext::CSimpleRTTITypeString,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of StringType"][::std::mem::size_of::<StringType>() - 16usize];
["Alignment of StringType"][::std::mem::align_of::<StringType>() - 8usize];
};
impl Default for StringType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct LocalizationStringType {
pub _base: root::RED4ext::CSimpleRTTITypeLocalizationString,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of LocalizationStringType"]
[::std::mem::size_of::<LocalizationStringType>() - 16usize];
["Alignment of LocalizationStringType"]
[::std::mem::align_of::<LocalizationStringType>() - 8usize];
};
impl Default for LocalizationStringType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct TweakDBIDType {
pub _base: root::RED4ext::CSimpleRTTITypeTweakDBID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TweakDBIDType"][::std::mem::size_of::<TweakDBIDType>() - 16usize];
["Alignment of TweakDBIDType"][::std::mem::align_of::<TweakDBIDType>() - 8usize];
};
impl Default for TweakDBIDType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct DataBufferType {
pub _base: root::RED4ext::CSimpleRTTITypeDataBuffer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of DataBufferType"][::std::mem::size_of::<DataBufferType>() - 16usize];
["Alignment of DataBufferType"][::std::mem::align_of::<DataBufferType>() - 8usize];
};
impl Default for DataBufferType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct SharedDataBufferType {
pub _base: root::RED4ext::CSimpleRTTITypeSharedDataBuffer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of SharedDataBufferType"]
[::std::mem::size_of::<SharedDataBufferType>() - 16usize];
["Alignment of SharedDataBufferType"]
[::std::mem::align_of::<SharedDataBufferType>() - 8usize];
};
impl Default for SharedDataBufferType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct serializationDeferredDataBufferType {
pub _base: root::RED4ext::CSimpleRTTITypeSerializationDeferredDataBuffer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of serializationDeferredDataBufferType"]
[::std::mem::size_of::<serializationDeferredDataBufferType>() - 16usize];
["Alignment of serializationDeferredDataBufferType"]
[::std::mem::align_of::<serializationDeferredDataBufferType>() - 8usize];
};
impl Default for serializationDeferredDataBufferType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct VariantType {
pub _base: root::RED4ext::CSimpleRTTITypeVariant,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of VariantType"][::std::mem::size_of::<VariantType>() - 16usize];
["Alignment of VariantType"][::std::mem::align_of::<VariantType>() - 8usize];
};
impl Default for VariantType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CDateTimeType {
pub _base: root::RED4ext::CSimpleRTTITypeCDateTime,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CDateTimeType"][::std::mem::size_of::<CDateTimeType>() - 16usize];
["Alignment of CDateTimeType"][::std::mem::align_of::<CDateTimeType>() - 8usize];
};
impl Default for CDateTimeType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CGUIDType {
pub _base: root::RED4ext::CSimpleRTTITypeCGUID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CGUIDType"][::std::mem::size_of::<CGUIDType>() - 16usize];
["Alignment of CGUIDType"][::std::mem::align_of::<CGUIDType>() - 8usize];
};
impl Default for CGUIDType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRUIDType {
pub _base: root::RED4ext::CSimpleRTTITypeCRUID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRUIDType"][::std::mem::size_of::<CRUIDType>() - 16usize];
["Alignment of CRUIDType"][::std::mem::align_of::<CRUIDType>() - 8usize];
};
impl Default for CRUIDType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CRUIDRefType {
pub _base: root::RED4ext::CSimpleRTTITypeCRUIDRef,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRUIDRefType"][::std::mem::size_of::<CRUIDRefType>() - 16usize];
["Alignment of CRUIDRefType"][::std::mem::align_of::<CRUIDRefType>() - 8usize];
};
impl Default for CRUIDRefType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct EditorObjectIDType {
pub _base: root::RED4ext::CSimpleRTTITypeEditorObjectID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of EditorObjectIDType"][::std::mem::size_of::<EditorObjectIDType>() - 16usize];
["Alignment of EditorObjectIDType"]
[::std::mem::align_of::<EditorObjectIDType>() - 8usize];
};
impl Default for EditorObjectIDType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct gamedataLocKeyWrapperType {
pub _base: root::RED4ext::CSimpleRTTITypeGamedataLocKeyWrapper,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of gamedataLocKeyWrapperType"]
[::std::mem::size_of::<gamedataLocKeyWrapperType>() - 16usize];
["Alignment of gamedataLocKeyWrapperType"]
[::std::mem::align_of::<gamedataLocKeyWrapperType>() - 8usize];
};
impl Default for gamedataLocKeyWrapperType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct MessageResourcePathType {
pub _base: root::RED4ext::CSimpleRTTITypeMessageResourcePath,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of MessageResourcePathType"]
[::std::mem::size_of::<MessageResourcePathType>() - 16usize];
["Alignment of MessageResourcePathType"]
[::std::mem::align_of::<MessageResourcePathType>() - 8usize];
};
impl Default for MessageResourcePathType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct NodeRefType {
pub _base: root::RED4ext::CSimpleRTTITypeNodeRef,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of NodeRefType"][::std::mem::size_of::<NodeRefType>() - 16usize];
["Alignment of NodeRefType"][::std::mem::align_of::<NodeRefType>() - 8usize];
};
impl Default for NodeRefType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct RuntimeEntityRefType {
pub _base: root::RED4ext::CSimpleRTTITypeRuntimeEntityRef,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RuntimeEntityRefType"]
[::std::mem::size_of::<RuntimeEntityRefType>() - 16usize];
["Alignment of RuntimeEntityRefType"]
[::std::mem::align_of::<RuntimeEntityRefType>() - 8usize];
};
impl Default for RuntimeEntityRefType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CArrayBase {
pub _base: root::RED4ext::CRTTIBaseArrayType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CArrayBase"][::std::mem::size_of::<CArrayBase>() - 24usize];
["Alignment of CArrayBase"][::std::mem::align_of::<CArrayBase>() - 8usize];
};
impl Default for CArrayBase {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CArray {
pub _base: root::RED4ext::CRTTIArrayType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CArray"][::std::mem::size_of::<CArray>() - 64usize];
["Alignment of CArray"][::std::mem::align_of::<CArray>() - 8usize];
};
impl Default for CArray {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CStaticArray {
pub _base: root::RED4ext::CRTTIStaticArrayType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CStaticArray"][::std::mem::size_of::<CStaticArray>() - 48usize];
["Alignment of CStaticArray"][::std::mem::align_of::<CStaticArray>() - 8usize];
};
impl Default for CStaticArray {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CNativeArray {
pub _base: root::RED4ext::CRTTINativeArrayType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CNativeArray"][::std::mem::size_of::<CNativeArray>() - 48usize];
["Alignment of CNativeArray"][::std::mem::align_of::<CNativeArray>() - 8usize];
};
impl Default for CNativeArray {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CHandle {
pub _base: root::RED4ext::CRTTIHandleType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CHandle"][::std::mem::size_of::<CHandle>() - 40usize];
["Alignment of CHandle"][::std::mem::align_of::<CHandle>() - 8usize];
};
impl Default for CHandle {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CWeakHandle {
pub _base: root::RED4ext::CRTTIWeakHandleType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CWeakHandle"][::std::mem::size_of::<CWeakHandle>() - 40usize];
["Alignment of CWeakHandle"][::std::mem::align_of::<CWeakHandle>() - 8usize];
};
impl Default for CWeakHandle {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CResourceReference {
pub _base: root::RED4ext::CRTTIResourceReferenceType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CResourceReference"][::std::mem::size_of::<CResourceReference>() - 40usize];
["Alignment of CResourceReference"]
[::std::mem::align_of::<CResourceReference>() - 8usize];
};
impl Default for CResourceReference {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CResourceAsyncReference {
pub _base: root::RED4ext::CRTTIResourceAsyncReferenceType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CResourceAsyncReference"]
[::std::mem::size_of::<CResourceAsyncReference>() - 40usize];
["Alignment of CResourceAsyncReference"]
[::std::mem::align_of::<CResourceAsyncReference>() - 8usize];
};
impl Default for CResourceAsyncReference {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CLegacySingleChannelCurve {
pub _base: root::RED4ext::CRTTILegacySingleChannelCurveType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CLegacySingleChannelCurve"]
[::std::mem::size_of::<CLegacySingleChannelCurve>() - 72usize];
["Alignment of CLegacySingleChannelCurve"]
[::std::mem::align_of::<CLegacySingleChannelCurve>() - 8usize];
};
impl Default for CLegacySingleChannelCurve {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct IScriptable {
pub _base: root::RED4ext::ISerializable,
pub nativeType: *mut root::RED4ext::CClass,
pub valueHolder: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IScriptable"][::std::mem::size_of::<IScriptable>() - 64usize];
["Alignment of IScriptable"][::std::mem::align_of::<IScriptable>() - 8usize];
["Offset of field: IScriptable::nativeType"]
[::std::mem::offset_of!(IScriptable, nativeType) - 48usize];
["Offset of field: IScriptable::valueHolder"]
[::std::mem::offset_of!(IScriptable, valueHolder) - 56usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?GetValueHolder@IScriptable@RED4ext@@QEAAPEAXXZ"]
pub fn IScriptable_GetValueHolder(
this: *mut root::RED4ext::IScriptable,
) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
#[link_name = "\u{1}?DestructValueHolder@IScriptable@RED4ext@@QEAAXXZ"]
pub fn IScriptable_DestructValueHolder(this: *mut root::RED4ext::IScriptable);
}
unsafe extern "C" {
#[link_name = "\u{1}??0IScriptable@RED4ext@@QEAA@XZ"]
pub fn IScriptable_IScriptable(this: *mut root::RED4ext::IScriptable);
}
impl Default for IScriptable {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl IScriptable {
#[inline]
pub unsafe fn GetValueHolder(&mut self) -> *mut ::std::os::raw::c_void {
IScriptable_GetValueHolder(self)
}
#[inline]
pub unsafe fn DestructValueHolder(&mut self) {
IScriptable_DestructValueHolder(self)
}
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
IScriptable_IScriptable(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}??1IScriptable@RED4ext@@UEAA@XZ"]
pub fn IScriptable_IScriptable_destructor(this: *mut root::RED4ext::IScriptable);
}
unsafe extern "C" {
#[link_name = "\u{1}?GetType@IScriptable@RED4ext@@UEAAPEAUCClass@2@XZ"]
pub fn IScriptable_GetType(
this: *mut ::std::os::raw::c_void,
) -> *mut root::RED4ext::CClass;
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_D8@IScriptable@RED4ext@@UEAAX_J0@Z"]
pub fn IScriptable_sub_D8(this: *mut ::std::os::raw::c_void, a1: i64, a2: i64);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_E0@IScriptable@RED4ext@@UEAAXXZ"]
pub fn IScriptable_sub_E0(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_E8@IScriptable@RED4ext@@UEAAXXZ"]
pub fn IScriptable_sub_E8(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_F0@IScriptable@RED4ext@@UEAAXXZ"]
pub fn IScriptable_sub_F0(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_F8@IScriptable@RED4ext@@UEAAXXZ"]
pub fn IScriptable_sub_F8(this: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
#[link_name = "\u{1}?sub_100@IScriptable@RED4ext@@UEAAXXZ"]
pub fn IScriptable_sub_100(this: *mut ::std::os::raw::c_void);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CProperty {
pub type_: *mut root::RED4ext::CBaseRTTIType,
pub name: root::RED4ext::CName,
pub group: root::RED4ext::CName,
pub parent: *mut root::RED4ext::CClass,
pub valueOffset: u32,
pub flags: root::RED4ext::CProperty_Flags,
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct CProperty_Flags {
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: root::__BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CProperty_Flags"][::std::mem::size_of::<CProperty_Flags>() - 8usize];
["Alignment of CProperty_Flags"][::std::mem::align_of::<CProperty_Flags>() - 8usize];
};
impl CProperty_Flags {
#[inline]
pub fn b0(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
}
#[inline]
pub fn set_b0(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b0_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b0_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b1(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
}
#[inline]
pub fn set_b1(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b1_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
1usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b1_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b2(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
}
#[inline]
pub fn set_b2(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b2_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
2usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b2_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
2usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b3(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
}
#[inline]
pub fn set_b3(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b3_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
3usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b3_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
3usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b4(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
}
#[inline]
pub fn set_b4(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b4_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
4usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b4_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
4usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isScripted(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
}
#[inline]
pub fn set_isScripted(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isScripted_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
5usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isScripted_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
5usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isReturn(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
}
#[inline]
pub fn set_isReturn(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isReturn_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
6usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isReturn_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
6usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b7(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
}
#[inline]
pub fn set_b7(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b7_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
7usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b7_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
7usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isLocalVar(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
}
#[inline]
pub fn set_isLocalVar(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isLocalVar_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
8usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isLocalVar_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
8usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isOut(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
}
#[inline]
pub fn set_isOut(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isOut_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
9usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isOut_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
9usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isOptional(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
}
#[inline]
pub fn set_isOptional(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isOptional_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
10usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isOptional_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
10usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b11(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
}
#[inline]
pub fn set_b11(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b11_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
11usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b11_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
11usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b12(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
}
#[inline]
pub fn set_b12(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b12_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
12usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b12_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
12usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b13(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
}
#[inline]
pub fn set_b13(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b13_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
13usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b13_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
13usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isOverriding(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
}
#[inline]
pub fn set_isOverriding(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isOverriding_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
14usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isOverriding_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
14usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b15(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
}
#[inline]
pub fn set_b15(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b15_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
15usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b15_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
15usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isPrivate(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
}
#[inline]
pub fn set_isPrivate(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(16usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isPrivate_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
16usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isPrivate_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
16usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isProtected(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
}
#[inline]
pub fn set_isProtected(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(17usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isProtected_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
17usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isProtected_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
17usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isPublic(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
}
#[inline]
pub fn set_isPublic(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(18usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isPublic_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
18usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isPublic_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
18usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b19(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u64) }
}
#[inline]
pub fn set_b19(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(19usize, 2u8, val as u64)
}
}
#[inline]
pub unsafe fn b19_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
19usize,
2u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b19_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
19usize,
2u8,
val as u64,
)
}
}
#[inline]
pub fn inValueHolder(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
}
#[inline]
pub fn set_inValueHolder(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(21usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn inValueHolder_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
21usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_inValueHolder_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
21usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b22(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 5u8) as u64) }
}
#[inline]
pub fn set_b22(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(22usize, 5u8, val as u64)
}
}
#[inline]
pub unsafe fn b22_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
22usize,
5u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b22_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
22usize,
5u8,
val as u64,
)
}
}
#[inline]
pub fn isHandle(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
}
#[inline]
pub fn set_isHandle(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(27usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isHandle_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
27usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isHandle_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
27usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isPersistent(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
}
#[inline]
pub fn set_isPersistent(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(28usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isPersistent_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
28usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isPersistent_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
28usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b29(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
}
#[inline]
pub fn set_b29(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(29usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b29_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
29usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b29_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
29usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b30(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
}
#[inline]
pub fn set_b30(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(30usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b30_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
30usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b30_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
30usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b31(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
}
#[inline]
pub fn set_b31(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(31usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b31_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
31usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b31_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
31usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b32(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
}
#[inline]
pub fn set_b32(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(32usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b32_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
32usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b32_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
32usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isSavable(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
}
#[inline]
pub fn set_isSavable(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(33usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isSavable_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
33usize,
1u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_isSavable_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
33usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b34(&self) -> u64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 30u8) as u64) }
}
#[inline]
pub fn set_b34(&mut self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(34usize, 30u8, val as u64)
}
}
#[inline]
pub unsafe fn b34_raw(this: *const Self) -> u64 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
34usize,
30u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_b34_raw(this: *mut Self, val: u64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
34usize,
30u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
b0: u64,
b1: u64,
b2: u64,
b3: u64,
b4: u64,
isScripted: u64,
isReturn: u64,
b7: u64,
isLocalVar: u64,
isOut: u64,
isOptional: u64,
b11: u64,
b12: u64,
b13: u64,
isOverriding: u64,
b15: u64,
isPrivate: u64,
isProtected: u64,
isPublic: u64,
b19: u64,
inValueHolder: u64,
b22: u64,
isHandle: u64,
isPersistent: u64,
b29: u64,
b30: u64,
b31: u64,
b32: u64,
isSavable: u64,
b34: u64,
) -> root::__BindgenBitfieldUnit<[u8; 8usize]> {
let mut __bindgen_bitfield_unit: root::__BindgenBitfieldUnit<[u8; 8usize]> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let b0: u64 = unsafe { ::std::mem::transmute(b0) };
b0 as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let b1: u64 = unsafe { ::std::mem::transmute(b1) };
b1 as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let b2: u64 = unsafe { ::std::mem::transmute(b2) };
b2 as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let b3: u64 = unsafe { ::std::mem::transmute(b3) };
b3 as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let b4: u64 = unsafe { ::std::mem::transmute(b4) };
b4 as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let isScripted: u64 = unsafe { ::std::mem::transmute(isScripted) };
isScripted as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let isReturn: u64 = unsafe { ::std::mem::transmute(isReturn) };
isReturn as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let b7: u64 = unsafe { ::std::mem::transmute(b7) };
b7 as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let isLocalVar: u64 = unsafe { ::std::mem::transmute(isLocalVar) };
isLocalVar as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let isOut: u64 = unsafe { ::std::mem::transmute(isOut) };
isOut as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let isOptional: u64 = unsafe { ::std::mem::transmute(isOptional) };
isOptional as u64
});
__bindgen_bitfield_unit.set(11usize, 1u8, {
let b11: u64 = unsafe { ::std::mem::transmute(b11) };
b11 as u64
});
__bindgen_bitfield_unit.set(12usize, 1u8, {
let b12: u64 = unsafe { ::std::mem::transmute(b12) };
b12 as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let b13: u64 = unsafe { ::std::mem::transmute(b13) };
b13 as u64
});
__bindgen_bitfield_unit.set(14usize, 1u8, {
let isOverriding: u64 = unsafe { ::std::mem::transmute(isOverriding) };
isOverriding as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let b15: u64 = unsafe { ::std::mem::transmute(b15) };
b15 as u64
});
__bindgen_bitfield_unit.set(16usize, 1u8, {
let isPrivate: u64 = unsafe { ::std::mem::transmute(isPrivate) };
isPrivate as u64
});
__bindgen_bitfield_unit.set(17usize, 1u8, {
let isProtected: u64 = unsafe { ::std::mem::transmute(isProtected) };
isProtected as u64
});
__bindgen_bitfield_unit.set(18usize, 1u8, {
let isPublic: u64 = unsafe { ::std::mem::transmute(isPublic) };
isPublic as u64
});
__bindgen_bitfield_unit.set(19usize, 2u8, {
let b19: u64 = unsafe { ::std::mem::transmute(b19) };
b19 as u64
});
__bindgen_bitfield_unit.set(21usize, 1u8, {
let inValueHolder: u64 = unsafe { ::std::mem::transmute(inValueHolder) };
inValueHolder as u64
});
__bindgen_bitfield_unit.set(22usize, 5u8, {
let b22: u64 = unsafe { ::std::mem::transmute(b22) };
b22 as u64
});
__bindgen_bitfield_unit.set(27usize, 1u8, {
let isHandle: u64 = unsafe { ::std::mem::transmute(isHandle) };
isHandle as u64
});
__bindgen_bitfield_unit.set(28usize, 1u8, {
let isPersistent: u64 = unsafe { ::std::mem::transmute(isPersistent) };
isPersistent as u64
});
__bindgen_bitfield_unit.set(29usize, 1u8, {
let b29: u64 = unsafe { ::std::mem::transmute(b29) };
b29 as u64
});
__bindgen_bitfield_unit.set(30usize, 1u8, {
let b30: u64 = unsafe { ::std::mem::transmute(b30) };
b30 as u64
});
__bindgen_bitfield_unit.set(31usize, 1u8, {
let b31: u64 = unsafe { ::std::mem::transmute(b31) };
b31 as u64
});
__bindgen_bitfield_unit.set(32usize, 1u8, {
let b32: u64 = unsafe { ::std::mem::transmute(b32) };
b32 as u64
});
__bindgen_bitfield_unit.set(33usize, 1u8, {
let isSavable: u64 = unsafe { ::std::mem::transmute(isSavable) };
isSavable as u64
});
__bindgen_bitfield_unit.set(34usize, 30u8, {
let b34: u64 = unsafe { ::std::mem::transmute(b34) };
b34 as u64
});
__bindgen_bitfield_unit
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CProperty"][::std::mem::size_of::<CProperty>() - 48usize];
["Alignment of CProperty"][::std::mem::align_of::<CProperty>() - 8usize];
["Offset of field: CProperty::type_"]
[::std::mem::offset_of!(CProperty, type_) - 0usize];
["Offset of field: CProperty::name"][::std::mem::offset_of!(CProperty, name) - 8usize];
["Offset of field: CProperty::group"]
[::std::mem::offset_of!(CProperty, group) - 16usize];
["Offset of field: CProperty::parent"]
[::std::mem::offset_of!(CProperty, parent) - 24usize];
["Offset of field: CProperty::valueOffset"]
[::std::mem::offset_of!(CProperty, valueOffset) - 32usize];
["Offset of field: CProperty::flags"]
[::std::mem::offset_of!(CProperty, flags) - 40usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Create@CProperty@RED4ext@@SAPEAU12@PEAUCBaseRTTIType@2@PEBDPEAUCClass@2@I1UFlags@12@@Z"]
pub fn CProperty_Create(
aType: *mut root::RED4ext::CBaseRTTIType,
aName: *const ::std::os::raw::c_char,
aParent: *mut root::RED4ext::CClass,
aValueOffset: u32,
aGroup: *const ::std::os::raw::c_char,
aFlags: root::RED4ext::CProperty_Flags,
) -> *mut root::RED4ext::CProperty;
}
unsafe extern "C" {
#[link_name = "\u{1}??0CProperty@RED4ext@@QEAA@PEAUCBaseRTTIType@1@PEBDPEAUCClass@1@I1UFlags@01@@Z"]
pub fn CProperty_CProperty(
this: *mut root::RED4ext::CProperty,
aType: *mut root::RED4ext::CBaseRTTIType,
aName: *const ::std::os::raw::c_char,
aParent: *mut root::RED4ext::CClass,
aValueOffset: u32,
aGroup: *const ::std::os::raw::c_char,
aFlags: root::RED4ext::CProperty_Flags,
);
}
impl Default for CProperty {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CProperty {
#[inline]
pub unsafe fn Create(
aType: *mut root::RED4ext::CBaseRTTIType,
aName: *const ::std::os::raw::c_char,
aParent: *mut root::RED4ext::CClass,
aValueOffset: u32,
aGroup: *const ::std::os::raw::c_char,
aFlags: root::RED4ext::CProperty_Flags,
) -> *mut root::RED4ext::CProperty {
CProperty_Create(aType, aName, aParent, aValueOffset, aGroup, aFlags)
}
#[inline]
pub unsafe fn new(
aType: *mut root::RED4ext::CBaseRTTIType,
aName: *const ::std::os::raw::c_char,
aParent: *mut root::RED4ext::CClass,
aValueOffset: u32,
aGroup: *const ::std::os::raw::c_char,
aFlags: root::RED4ext::CProperty_Flags,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CProperty_CProperty(
__bindgen_tmp.as_mut_ptr(),
aType,
aName,
aParent,
aValueOffset,
aGroup,
aFlags,
);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JobFamily {
pub name: *const ::std::os::raw::c_char,
pub unk08: *const ::std::os::raw::c_char,
pub unk10: *const ::std::os::raw::c_char,
pub unk18: u32,
pub unk1C: u32,
pub unk20: u32,
pub unk24: u32,
pub hash: u32,
pub unk2C: u32,
pub unk30: u32,
pub unk34: u32,
pub unk38: u16,
pub unk3C: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of JobFamily"][::std::mem::size_of::<JobFamily>() - 64usize];
["Alignment of JobFamily"][::std::mem::align_of::<JobFamily>() - 8usize];
["Offset of field: JobFamily::name"][::std::mem::offset_of!(JobFamily, name) - 0usize];
["Offset of field: JobFamily::unk08"]
[::std::mem::offset_of!(JobFamily, unk08) - 8usize];
["Offset of field: JobFamily::unk10"]
[::std::mem::offset_of!(JobFamily, unk10) - 16usize];
["Offset of field: JobFamily::unk18"]
[::std::mem::offset_of!(JobFamily, unk18) - 24usize];
["Offset of field: JobFamily::unk1C"]
[::std::mem::offset_of!(JobFamily, unk1C) - 28usize];
["Offset of field: JobFamily::unk20"]
[::std::mem::offset_of!(JobFamily, unk20) - 32usize];
["Offset of field: JobFamily::unk24"]
[::std::mem::offset_of!(JobFamily, unk24) - 36usize];
["Offset of field: JobFamily::hash"][::std::mem::offset_of!(JobFamily, hash) - 40usize];
["Offset of field: JobFamily::unk2C"]
[::std::mem::offset_of!(JobFamily, unk2C) - 44usize];
["Offset of field: JobFamily::unk30"]
[::std::mem::offset_of!(JobFamily, unk30) - 48usize];
["Offset of field: JobFamily::unk34"]
[::std::mem::offset_of!(JobFamily, unk34) - 52usize];
["Offset of field: JobFamily::unk38"]
[::std::mem::offset_of!(JobFamily, unk38) - 56usize];
["Offset of field: JobFamily::unk3C"]
[::std::mem::offset_of!(JobFamily, unk3C) - 60usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0JobFamily@RED4ext@@QEAA@PEBD@Z"]
pub fn JobFamily_JobFamily(
this: *mut root::RED4ext::JobFamily,
aName: *const ::std::os::raw::c_char,
);
}
impl Default for JobFamily {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl JobFamily {
#[inline]
pub unsafe fn new(aName: *const ::std::os::raw::c_char) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
JobFamily_JobFamily(__bindgen_tmp.as_mut_ptr(), aName);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct JobParamSet {
pub unk00: u8,
pub unk01: u8,
pub unk02: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of JobParamSet"][::std::mem::size_of::<JobParamSet>() - 3usize];
["Alignment of JobParamSet"][::std::mem::align_of::<JobParamSet>() - 1usize];
["Offset of field: JobParamSet::unk00"]
[::std::mem::offset_of!(JobParamSet, unk00) - 0usize];
["Offset of field: JobParamSet::unk01"]
[::std::mem::offset_of!(JobParamSet, unk01) - 1usize];
["Offset of field: JobParamSet::unk02"]
[::std::mem::offset_of!(JobParamSet, unk02) - 2usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0JobParamSet@RED4ext@@QEAA@XZ"]
pub fn JobParamSet_JobParamSet(this: *mut root::RED4ext::JobParamSet);
}
impl JobParamSet {
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
JobParamSet_JobParamSet(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct JobInternalHandle {
pub unk00: u64,
pub unk08: u64,
pub unk10: u64,
pub unk18: u32,
pub unk1C: u32,
pub unk20: u8,
pub params: root::RED4ext::JobParamSet,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of JobInternalHandle"][::std::mem::size_of::<JobInternalHandle>() - 40usize];
["Alignment of JobInternalHandle"]
[::std::mem::align_of::<JobInternalHandle>() - 8usize];
["Offset of field: JobInternalHandle::unk00"]
[::std::mem::offset_of!(JobInternalHandle, unk00) - 0usize];
["Offset of field: JobInternalHandle::unk08"]
[::std::mem::offset_of!(JobInternalHandle, unk08) - 8usize];
["Offset of field: JobInternalHandle::unk10"]
[::std::mem::offset_of!(JobInternalHandle, unk10) - 16usize];
["Offset of field: JobInternalHandle::unk18"]
[::std::mem::offset_of!(JobInternalHandle, unk18) - 24usize];
["Offset of field: JobInternalHandle::unk1C"]
[::std::mem::offset_of!(JobInternalHandle, unk1C) - 28usize];
["Offset of field: JobInternalHandle::unk20"]
[::std::mem::offset_of!(JobInternalHandle, unk20) - 32usize];
["Offset of field: JobInternalHandle::params"]
[::std::mem::offset_of!(JobInternalHandle, params) - 33usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct JobHandle {
pub internal: *mut root::RED4ext::JobInternalHandle,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of JobHandle"][::std::mem::size_of::<JobHandle>() - 8usize];
["Alignment of JobHandle"][::std::mem::align_of::<JobHandle>() - 8usize];
["Offset of field: JobHandle::internal"]
[::std::mem::offset_of!(JobHandle, internal) - 0usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Join@JobHandle@RED4ext@@QEAAXAEBV12@@Z"]
pub fn JobHandle_Join(
this: *mut root::RED4ext::JobHandle,
aOther: *const root::RED4ext::JobHandle,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0JobHandle@RED4ext@@QEAA@_K@Z"]
pub fn JobHandle_JobHandle(this: *mut root::RED4ext::JobHandle, aUnk: usize);
}
unsafe extern "C" {
#[link_name = "\u{1}??0JobHandle@RED4ext@@QEAA@AEBV01@@Z"]
pub fn JobHandle_JobHandle1(
this: *mut root::RED4ext::JobHandle,
arg1: *const root::RED4ext::JobHandle,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0JobHandle@RED4ext@@QEAA@$$QEAV01@@Z"]
pub fn JobHandle_JobHandle2(
this: *mut root::RED4ext::JobHandle,
arg1: *mut root::RED4ext::JobHandle,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??1JobHandle@RED4ext@@QEAA@XZ"]
pub fn JobHandle_JobHandle_destructor(this: *mut root::RED4ext::JobHandle);
}
impl Default for JobHandle {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl JobHandle {
#[inline]
pub unsafe fn Join(&mut self, aOther: *const root::RED4ext::JobHandle) {
JobHandle_Join(self, aOther)
}
#[inline]
pub unsafe fn new(aUnk: usize) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
JobHandle_JobHandle(__bindgen_tmp.as_mut_ptr(), aUnk);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(arg1: *const root::RED4ext::JobHandle) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
JobHandle_JobHandle1(__bindgen_tmp.as_mut_ptr(), arg1);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new2(arg1: *mut root::RED4ext::JobHandle) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
JobHandle_JobHandle2(__bindgen_tmp.as_mut_ptr(), arg1);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
JobHandle_JobHandle_destructor(self)
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct JobGroup {
pub unk00: u64,
pub unk08: u64,
pub unk10: u64,
pub unk18: u64,
pub unk20: u64,
pub unk28: u64,
pub params: root::RED4ext::JobParamSet,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of JobGroup"][::std::mem::size_of::<JobGroup>() - 56usize];
["Alignment of JobGroup"][::std::mem::align_of::<JobGroup>() - 8usize];
["Offset of field: JobGroup::unk00"][::std::mem::offset_of!(JobGroup, unk00) - 0usize];
["Offset of field: JobGroup::unk08"][::std::mem::offset_of!(JobGroup, unk08) - 8usize];
["Offset of field: JobGroup::unk10"][::std::mem::offset_of!(JobGroup, unk10) - 16usize];
["Offset of field: JobGroup::unk18"][::std::mem::offset_of!(JobGroup, unk18) - 24usize];
["Offset of field: JobGroup::unk20"][::std::mem::offset_of!(JobGroup, unk20) - 32usize];
["Offset of field: JobGroup::unk28"][::std::mem::offset_of!(JobGroup, unk28) - 40usize];
["Offset of field: JobGroup::params"]
[::std::mem::offset_of!(JobGroup, params) - 48usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JobInstance {
pub handler: root::RED4ext::JobInstance_HandleFunc<::std::os::raw::c_void>,
pub target: root::RED4ext::JobInstance_TargetPtr<::std::os::raw::c_void>,
pub family: *mut root::RED4ext::JobFamily,
pub unk18: u64,
}
pub type JobInstance_TargetPtr<T> = *mut T;
pub type JobInstance_HandleFunc<T> = ::std::option::Option<
unsafe extern "C" fn(
aTarget: root::RED4ext::JobInstance_TargetPtr<T>,
aGroup: *const root::RED4ext::JobGroup,
),
>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of JobInstance"][::std::mem::size_of::<JobInstance>() - 32usize];
["Alignment of JobInstance"][::std::mem::align_of::<JobInstance>() - 8usize];
["Offset of field: JobInstance::handler"]
[::std::mem::offset_of!(JobInstance, handler) - 0usize];
["Offset of field: JobInstance::target"]
[::std::mem::offset_of!(JobInstance, target) - 8usize];
["Offset of field: JobInstance::family"]
[::std::mem::offset_of!(JobInstance, family) - 16usize];
["Offset of field: JobInstance::unk18"]
[::std::mem::offset_of!(JobInstance, unk18) - 24usize];
};
impl Default for JobInstance {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JobClosure {
pub _base: root::RED4ext::JobInstance,
}
pub type JobClosure_AllocatorType = root::RED4ext::Memory::Jobs2DataAllocator;
pub type JobClosure_ClosureType<L> = L;
pub type JobClosure_ClosurePtr<L> = *mut L;
impl Default for JobClosure {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct JobQueue {
pub unk00: *const ::std::os::raw::c_char,
pub unk08: usize,
pub unk10: root::RED4ext::JobHandle,
pub unk18: root::RED4ext::JobHandle,
pub unk20: usize,
pub params: root::RED4ext::JobParamSet,
pub unk2C: u32,
pub captured: bool,
pub unk31: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of JobQueue"][::std::mem::size_of::<JobQueue>() - 56usize];
["Alignment of JobQueue"][::std::mem::align_of::<JobQueue>() - 8usize];
["Offset of field: JobQueue::unk00"][::std::mem::offset_of!(JobQueue, unk00) - 0usize];
["Offset of field: JobQueue::unk08"][::std::mem::offset_of!(JobQueue, unk08) - 8usize];
["Offset of field: JobQueue::unk10"][::std::mem::offset_of!(JobQueue, unk10) - 16usize];
["Offset of field: JobQueue::unk18"][::std::mem::offset_of!(JobQueue, unk18) - 24usize];
["Offset of field: JobQueue::unk20"][::std::mem::offset_of!(JobQueue, unk20) - 32usize];
["Offset of field: JobQueue::params"]
[::std::mem::offset_of!(JobQueue, params) - 40usize];
["Offset of field: JobQueue::unk2C"][::std::mem::offset_of!(JobQueue, unk2C) - 44usize];
["Offset of field: JobQueue::captured"]
[::std::mem::offset_of!(JobQueue, captured) - 48usize];
["Offset of field: JobQueue::unk31"][::std::mem::offset_of!(JobQueue, unk31) - 49usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Wait@JobQueue@RED4ext@@QEAAXAEBVJobHandle@2@@Z"]
pub fn JobQueue_Wait(
this: *mut root::RED4ext::JobQueue,
aJob: *const root::RED4ext::JobHandle,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Capture@JobQueue@RED4ext@@QEAA?AVJobHandle@2@XZ"]
pub fn JobQueue_Capture(this: *mut root::RED4ext::JobQueue)
-> root::RED4ext::JobHandle;
}
unsafe extern "C" {
#[link_name = "\u{1}??0JobQueue@RED4ext@@QEAA@AEBUJobGroup@1@@Z"]
pub fn JobQueue_JobQueue(
this: *mut root::RED4ext::JobQueue,
aGroup: *const root::RED4ext::JobGroup,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0JobQueue@RED4ext@@QEAA@UJobParamSet@1@_K@Z"]
pub fn JobQueue_JobQueue1(
this: *mut root::RED4ext::JobQueue,
aParams: root::RED4ext::JobParamSet,
aUnk: usize,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??1JobQueue@RED4ext@@QEAA@XZ"]
pub fn JobQueue_JobQueue_destructor(this: *mut root::RED4ext::JobQueue);
}
impl Default for JobQueue {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl JobQueue {
#[inline]
pub unsafe fn Wait(&mut self, aJob: *const root::RED4ext::JobHandle) {
JobQueue_Wait(self, aJob)
}
#[inline]
pub unsafe fn Capture(&mut self) -> root::RED4ext::JobHandle {
JobQueue_Capture(self)
}
#[inline]
pub unsafe fn new(aGroup: *const root::RED4ext::JobGroup) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
JobQueue_JobQueue(__bindgen_tmp.as_mut_ptr(), aGroup);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(aParams: root::RED4ext::JobParamSet, aUnk: usize) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
JobQueue_JobQueue1(__bindgen_tmp.as_mut_ptr(), aParams, aUnk);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
JobQueue_JobQueue_destructor(self)
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct TLS {
pub unk00: [u8; 330usize],
pub jobParam: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TLS"][::std::mem::size_of::<TLS>() - 331usize];
["Alignment of TLS"][::std::mem::align_of::<TLS>() - 1usize];
["Offset of field: TLS::unk00"][::std::mem::offset_of!(TLS, unk00) - 0usize];
["Offset of field: TLS::jobParam"][::std::mem::offset_of!(TLS, jobParam) - 330usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Get@TLS@RED4ext@@SAPEAU12@XZ"]
pub fn TLS_Get() -> *mut root::RED4ext::TLS;
}
impl Default for TLS {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl TLS {
#[inline]
pub unsafe fn Get() -> *mut root::RED4ext::TLS {
TLS_Get()
}
}
#[repr(C)]
pub struct RawBufferAllocator__bindgen_vtable {
pub RawBufferAllocator_ReallocAligned:
unsafe extern "C" fn(
this: *const RawBufferAllocator,
aData: *mut ::std::os::raw::c_void,
aSize: u32,
aAlignment: u32,
) -> *mut ::std::os::raw::c_void,
pub RawBufferAllocator_Free: unsafe extern "C" fn(
this: *const RawBufferAllocator,
aData: *mut ::std::os::raw::c_void,
),
pub RawBufferAllocator_GetAllocator:
unsafe extern "C" fn(
this: *const RawBufferAllocator,
) -> *mut root::RED4ext::Memory::IAllocator,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RawBufferAllocator {
pub vtable_: *const RawBufferAllocator__bindgen_vtable,
pub allocator: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RawBufferAllocator"][::std::mem::size_of::<RawBufferAllocator>() - 16usize];
["Alignment of RawBufferAllocator"]
[::std::mem::align_of::<RawBufferAllocator>() - 8usize];
["Offset of field: RawBufferAllocator::allocator"]
[::std::mem::offset_of!(RawBufferAllocator, allocator) - 8usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0RawBufferAllocator@RED4ext@@QEAA@PEAUIAllocator@Memory@1@@Z"]
pub fn RawBufferAllocator_RawBufferAllocator(
this: *mut root::RED4ext::RawBufferAllocator,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
);
}
impl Default for RawBufferAllocator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl RawBufferAllocator {
#[inline]
pub unsafe fn new(aAllocator: *mut root::RED4ext::Memory::IAllocator) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
RawBufferAllocator_RawBufferAllocator(__bindgen_tmp.as_mut_ptr(), aAllocator);
__bindgen_tmp.assume_init()
}
}
unsafe extern "C" {
#[link_name = "\u{1}?ReallocAligned@RawBufferAllocator@RED4ext@@UEBAPEAXPEAXII@Z"]
pub fn RawBufferAllocator_ReallocAligned(
this: *mut ::std::os::raw::c_void,
aData: *mut ::std::os::raw::c_void,
aSize: u32,
aAlignment: u32,
) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
#[link_name = "\u{1}?Free@RawBufferAllocator@RED4ext@@UEBAXPEAX@Z"]
pub fn RawBufferAllocator_Free(
this: *mut ::std::os::raw::c_void,
aData: *mut ::std::os::raw::c_void,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?GetAllocator@RawBufferAllocator@RED4ext@@UEBAPEAUIAllocator@Memory@2@XZ"]
pub fn RawBufferAllocator_GetAllocator(
this: *mut ::std::os::raw::c_void,
) -> *mut root::RED4ext::Memory::IAllocator;
}
#[repr(C)]
#[derive(Debug)]
pub struct RawBuffer {
pub data: *mut ::std::os::raw::c_void,
pub size: u32,
pub alignment: u32,
pub allocator: [u64; 2usize],
}
pub type RawBuffer_AllocatorType = root::RED4ext::Memory::EngineAllocator;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RawBuffer"][::std::mem::size_of::<RawBuffer>() - 32usize];
["Alignment of RawBuffer"][::std::mem::align_of::<RawBuffer>() - 8usize];
["Offset of field: RawBuffer::data"][::std::mem::offset_of!(RawBuffer, data) - 0usize];
["Offset of field: RawBuffer::size"][::std::mem::offset_of!(RawBuffer, size) - 8usize];
["Offset of field: RawBuffer::alignment"]
[::std::mem::offset_of!(RawBuffer, alignment) - 12usize];
["Offset of field: RawBuffer::allocator"]
[::std::mem::offset_of!(RawBuffer, allocator) - 16usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?GetAllocator@RawBuffer@RED4ext@@QEBAPEAUIAllocator@Memory@2@XZ"]
pub fn RawBuffer_GetAllocator(
this: *const root::RED4ext::RawBuffer,
) -> *mut root::RED4ext::Memory::IAllocator;
}
unsafe extern "C" {
#[link_name = "\u{1}?Initialize@RawBuffer@RED4ext@@QEAAXPEAUIAllocator@Memory@2@II@Z"]
pub fn RawBuffer_Initialize(
this: *mut root::RED4ext::RawBuffer,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
aSize: u32,
aAlignment: u32,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?Resize@RawBuffer@RED4ext@@QEAAXI@Z"]
pub fn RawBuffer_Resize(this: *mut root::RED4ext::RawBuffer, aSize: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}??0RawBuffer@RED4ext@@QEAA@XZ"]
pub fn RawBuffer_RawBuffer(this: *mut root::RED4ext::RawBuffer);
}
unsafe extern "C" {
#[link_name = "\u{1}??0RawBuffer@RED4ext@@QEAA@PEAXII@Z"]
pub fn RawBuffer_RawBuffer1(
this: *mut root::RED4ext::RawBuffer,
aData: *mut ::std::os::raw::c_void,
aSize: u32,
aAlignment: u32,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??1RawBuffer@RED4ext@@QEAA@XZ"]
pub fn RawBuffer_RawBuffer_destructor(this: *mut root::RED4ext::RawBuffer);
}
impl Default for RawBuffer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl RawBuffer {
#[inline]
pub unsafe fn GetAllocator(&self) -> *mut root::RED4ext::Memory::IAllocator {
RawBuffer_GetAllocator(self)
}
#[inline]
pub unsafe fn Initialize(
&mut self,
aAllocator: *mut root::RED4ext::Memory::IAllocator,
aSize: u32,
aAlignment: u32,
) {
RawBuffer_Initialize(self, aAllocator, aSize, aAlignment)
}
#[inline]
pub unsafe fn Resize(&mut self, aSize: u32) {
RawBuffer_Resize(self, aSize)
}
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
RawBuffer_RawBuffer(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(
aData: *mut ::std::os::raw::c_void,
aSize: u32,
aAlignment: u32,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
RawBuffer_RawBuffer1(__bindgen_tmp.as_mut_ptr(), aData, aSize, aAlignment);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
RawBuffer_RawBuffer_destructor(self)
}
}
#[repr(C)]
#[derive(Debug)]
pub struct DataBuffer {
pub buffer: root::RED4ext::RawBuffer,
pub unk20: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of DataBuffer"][::std::mem::size_of::<DataBuffer>() - 40usize];
["Alignment of DataBuffer"][::std::mem::align_of::<DataBuffer>() - 8usize];
["Offset of field: DataBuffer::buffer"]
[::std::mem::offset_of!(DataBuffer, buffer) - 0usize];
["Offset of field: DataBuffer::unk20"]
[::std::mem::offset_of!(DataBuffer, unk20) - 32usize];
};
impl Default for DataBuffer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SharedDataBuffer {
pub unk00: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of SharedDataBuffer"][::std::mem::size_of::<SharedDataBuffer>() - 8usize];
["Alignment of SharedDataBuffer"][::std::mem::align_of::<SharedDataBuffer>() - 8usize];
["Offset of field: SharedDataBuffer::unk00"]
[::std::mem::offset_of!(SharedDataBuffer, unk00) - 0usize];
};
pub mod DeferredDataBufferState {
pub type Type = u8;
pub const Unloaded: Type = 0;
pub const Loading: Type = 1;
pub const Loaded: Type = 2;
}
#[repr(C)]
#[derive(Debug)]
pub struct DeferredDataBuffer {
pub temp: root::RED4ext::RawBuffer,
pub raw: root::RED4ext::SharedPtr<root::RED4ext::RawBuffer>,
pub unk30: *mut ::std::os::raw::c_void,
pub unk38: u8,
pub unk40: u64,
pub unk48: u64,
pub unk50: u32,
pub state: root::RED4ext::DeferredDataBufferState::Type,
pub lock: root::RED4ext::SharedSpinLock,
pub unk56: u16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of DeferredDataBuffer"][::std::mem::size_of::<DeferredDataBuffer>() - 88usize];
["Alignment of DeferredDataBuffer"]
[::std::mem::align_of::<DeferredDataBuffer>() - 8usize];
["Offset of field: DeferredDataBuffer::temp"]
[::std::mem::offset_of!(DeferredDataBuffer, temp) - 0usize];
["Offset of field: DeferredDataBuffer::raw"]
[::std::mem::offset_of!(DeferredDataBuffer, raw) - 32usize];
["Offset of field: DeferredDataBuffer::unk30"]
[::std::mem::offset_of!(DeferredDataBuffer, unk30) - 48usize];
["Offset of field: DeferredDataBuffer::unk38"]
[::std::mem::offset_of!(DeferredDataBuffer, unk38) - 56usize];
["Offset of field: DeferredDataBuffer::unk40"]
[::std::mem::offset_of!(DeferredDataBuffer, unk40) - 64usize];
["Offset of field: DeferredDataBuffer::unk48"]
[::std::mem::offset_of!(DeferredDataBuffer, unk48) - 72usize];
["Offset of field: DeferredDataBuffer::unk50"]
[::std::mem::offset_of!(DeferredDataBuffer, unk50) - 80usize];
["Offset of field: DeferredDataBuffer::state"]
[::std::mem::offset_of!(DeferredDataBuffer, state) - 84usize];
["Offset of field: DeferredDataBuffer::lock"]
[::std::mem::offset_of!(DeferredDataBuffer, lock) - 85usize];
["Offset of field: DeferredDataBuffer::unk56"]
[::std::mem::offset_of!(DeferredDataBuffer, unk56) - 86usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?LoadAsync@DeferredDataBuffer@RED4ext@@QEAA?AV?$SharedPtr@UDeferredDataBufferToken@RED4ext@@@2@XZ"]
pub fn DeferredDataBuffer_LoadAsync(
this: *mut root::RED4ext::DeferredDataBuffer,
) -> root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferToken>;
}
unsafe extern "C" {
#[link_name = "\u{1}?LoadCopyAsync@DeferredDataBuffer@RED4ext@@QEAA?AV?$SharedPtr@UDeferredDataBufferCopyToken@RED4ext@@@2@XZ"]
pub fn DeferredDataBuffer_LoadCopyAsync(
this: *mut root::RED4ext::DeferredDataBuffer,
) -> root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferCopyToken>;
}
impl Default for DeferredDataBuffer {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl DeferredDataBuffer {
#[inline]
pub unsafe fn LoadAsync(
&mut self,
) -> root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferToken> {
DeferredDataBuffer_LoadAsync(self)
}
#[inline]
pub unsafe fn LoadCopyAsync(
&mut self,
) -> root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferCopyToken> {
DeferredDataBuffer_LoadCopyAsync(self)
}
}
#[repr(C)]
#[derive(Debug)]
pub struct DeferredDataBufferToken {
pub buffer: *mut root::RED4ext::DeferredDataBuffer,
pub job: root::RED4ext::JobHandle,
}
pub type DeferredDataBufferToken_AllocatorType = root::RED4ext::Memory::EngineAllocator;
pub type DeferredDataBufferToken_LoadedCallback = root::__BindgenOpaqueArray<u64, 5usize>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of DeferredDataBufferToken"]
[::std::mem::size_of::<DeferredDataBufferToken>() - 16usize];
["Alignment of DeferredDataBufferToken"]
[::std::mem::align_of::<DeferredDataBufferToken>() - 8usize];
["Offset of field: DeferredDataBufferToken::buffer"]
[::std::mem::offset_of!(DeferredDataBufferToken, buffer) - 0usize];
["Offset of field: DeferredDataBufferToken::job"]
[::std::mem::offset_of!(DeferredDataBufferToken, job) - 8usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?OnLoaded@DeferredDataBufferToken@RED4ext@@QEAAX$$QEAV?$Callback@P6AXAEAUDeferredDataBuffer@RED4ext@@@Z$0CA@@2@@Z"]
pub fn DeferredDataBufferToken_OnLoaded(
this: *mut root::RED4ext::DeferredDataBufferToken,
aCallback: *mut root::RED4ext::DeferredDataBufferToken_LoadedCallback,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0DeferredDataBufferToken@RED4ext@@QEAA@AEAUDeferredDataBuffer@1@AEAVJobHandle@1@@Z"]
pub fn DeferredDataBufferToken_DeferredDataBufferToken(
this: *mut root::RED4ext::DeferredDataBufferToken,
aBuffer: *mut root::RED4ext::DeferredDataBuffer,
aJob: *mut root::RED4ext::JobHandle,
);
}
impl Default for DeferredDataBufferToken {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl DeferredDataBufferToken {
#[inline]
pub unsafe fn OnLoaded(
&mut self,
aCallback: *mut root::RED4ext::DeferredDataBufferToken_LoadedCallback,
) {
DeferredDataBufferToken_OnLoaded(self, aCallback)
}
#[inline]
pub unsafe fn new(
aBuffer: *mut root::RED4ext::DeferredDataBuffer,
aJob: *mut root::RED4ext::JobHandle,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
DeferredDataBufferToken_DeferredDataBufferToken(
__bindgen_tmp.as_mut_ptr(),
aBuffer,
aJob,
);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug)]
pub struct DeferredDataBufferCopyToken {
pub self_: root::RED4ext::WeakPtr<root::RED4ext::DeferredDataBufferCopyToken>,
pub job: root::RED4ext::JobHandle,
pub raw: root::RED4ext::SharedPtr<root::RED4ext::RawBuffer>,
pub unk28: *mut ::std::os::raw::c_void,
pub unk30: *mut ::std::os::raw::c_void,
}
pub type DeferredDataBufferCopyToken_AllocatorType = root::RED4ext::Memory::EngineAllocator;
pub type DeferredDataBufferCopyToken_LoadedCallback =
root::__BindgenOpaqueArray<u64, 5usize>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of DeferredDataBufferCopyToken"]
[::std::mem::size_of::<DeferredDataBufferCopyToken>() - 56usize];
["Alignment of DeferredDataBufferCopyToken"]
[::std::mem::align_of::<DeferredDataBufferCopyToken>() - 8usize];
["Offset of field: DeferredDataBufferCopyToken::self_"]
[::std::mem::offset_of!(DeferredDataBufferCopyToken, self_) - 0usize];
["Offset of field: DeferredDataBufferCopyToken::job"]
[::std::mem::offset_of!(DeferredDataBufferCopyToken, job) - 16usize];
["Offset of field: DeferredDataBufferCopyToken::raw"]
[::std::mem::offset_of!(DeferredDataBufferCopyToken, raw) - 24usize];
["Offset of field: DeferredDataBufferCopyToken::unk28"]
[::std::mem::offset_of!(DeferredDataBufferCopyToken, unk28) - 40usize];
["Offset of field: DeferredDataBufferCopyToken::unk30"]
[::std::mem::offset_of!(DeferredDataBufferCopyToken, unk30) - 48usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?OnLoaded@DeferredDataBufferCopyToken@RED4ext@@QEBAX$$QEAV?$Callback@P6AXAEBV?$SharedPtr@UDeferredDataBufferCopyToken@RED4ext@@@RED4ext@@@Z$0CA@@2@@Z"]
pub fn DeferredDataBufferCopyToken_OnLoaded(
this: *const root::RED4ext::DeferredDataBufferCopyToken,
aCallback: *mut root::RED4ext::DeferredDataBufferCopyToken_LoadedCallback,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??1DeferredDataBufferCopyToken@RED4ext@@QEAA@XZ"]
pub fn DeferredDataBufferCopyToken_DeferredDataBufferCopyToken_destructor(
this: *mut root::RED4ext::DeferredDataBufferCopyToken,
);
}
impl Default for DeferredDataBufferCopyToken {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl DeferredDataBufferCopyToken {
#[inline]
pub unsafe fn OnLoaded(
&self,
aCallback: *mut root::RED4ext::DeferredDataBufferCopyToken_LoadedCallback,
) {
DeferredDataBufferCopyToken_OnLoaded(self, aCallback)
}
#[inline]
pub unsafe fn destruct(&mut self) {
DeferredDataBufferCopyToken_DeferredDataBufferCopyToken_destructor(self)
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct NodeRef {
pub hash: u64,
}
unsafe extern "C" {
#[link_name = "\u{1}?GlobalRoot@NodeRef@RED4ext@@2_KB"]
pub static NodeRef_GlobalRoot: u64;
}
unsafe extern "C" {
#[link_name = "\u{1}?RelativeRoot@NodeRef@RED4ext@@2_KB"]
pub static NodeRef_RelativeRoot: u64;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of NodeRef"][::std::mem::size_of::<NodeRef>() - 8usize];
["Alignment of NodeRef"][::std::mem::align_of::<NodeRef>() - 8usize];
["Offset of field: NodeRef::hash"][::std::mem::offset_of!(NodeRef, hash) - 0usize];
};
pub mod world {
#[allow(unused_imports)]
use self::super::super::super::root;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct GlobalNodeRef {
pub _base: root::RED4ext::NodeRef,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of GlobalNodeRef"][::std::mem::size_of::<GlobalNodeRef>() - 8usize];
["Alignment of GlobalNodeRef"][::std::mem::align_of::<GlobalNodeRef>() - 8usize];
};
}
pub type GlobalNodeRef = root::RED4ext::world::GlobalNodeRef;
pub type worldGlobalNodeRef = root::RED4ext::world::GlobalNodeRef;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ResourcePath {
pub hash: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ResourcePath"][::std::mem::size_of::<ResourcePath>() - 8usize];
["Alignment of ResourcePath"][::std::mem::align_of::<ResourcePath>() - 8usize];
["Offset of field: ResourcePath::hash"]
[::std::mem::offset_of!(ResourcePath, hash) - 0usize];
};
pub mod ECookingPlatform {
pub type Type = u8;
pub const PLATFORM_None: Type = 0;
pub const PLATFORM_PC: Type = 1;
pub const PLATFORM_XboxOne: Type = 2;
pub const PLATFORM_PS4: Type = 3;
pub const PLATFORM_PS5: Type = 4;
pub const PLATFORM_XSX: Type = 5;
pub const PLATFORM_WindowsServer: Type = 6;
pub const PLATFORM_LinuxServer: Type = 7;
pub const PLATFORM_GGP: Type = 8;
}
#[repr(C)]
#[derive(Debug)]
pub struct CResource {
pub _base: root::RED4ext::ISerializable,
pub path: root::RED4ext::ResourcePath,
pub cookingPlatform: root::RED4ext::ECookingPlatform::Type,
}
pub const CResource_NAME: &[u8; 10] = b"CResource\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@CResource@RED4ext@@2QEBDEB"]
pub static CResource_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CResource"][::std::mem::size_of::<CResource>() - 64usize];
["Alignment of CResource"][::std::mem::align_of::<CResource>() - 8usize];
["Offset of field: CResource::path"][::std::mem::offset_of!(CResource, path) - 48usize];
["Offset of field: CResource::cookingPlatform"]
[::std::mem::offset_of!(CResource, cookingPlatform) - 56usize];
};
impl Default for CResource {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct ResourceToken<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub self_: root::RED4ext::WeakPtr<root::RED4ext::ResourceToken<T>>,
pub dependencies: root::RED4ext::DynArray<
root::RED4ext::SharedPtr<root::RED4ext::ResourceToken<root::RED4ext::CResource>>,
>,
pub lock: root::RED4ext::SharedSpinLock,
pub resource: root::RED4ext::Handle<T>,
pub unk38: *mut ::std::os::raw::c_void,
pub unk40: *mut ::std::os::raw::c_void,
pub path: root::RED4ext::ResourcePath,
pub job: root::RED4ext::JobHandle,
pub finished: i32,
pub error: u8,
pub unk5D: u8,
pub unk5E: u8,
pub unk5F: u8,
}
pub type ResourceToken_AllocatorType = root::RED4ext::Memory::EngineAllocator;
pub type ResourceToken_LoadedCallback = u8;
impl<T> Default for ResourceToken<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ResourceRequest {
pub path: root::RED4ext::ResourcePath,
pub unk08: u64,
pub unk10: bool,
pub disablePreInitialization: bool,
pub disableImports: bool,
pub disablePostLoad: bool,
pub unk14: bool,
pub unk15: bool,
pub unk16: bool,
pub archiveHandle: i32,
pub unk1C: i32,
pub unk20: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ResourceRequest"][::std::mem::size_of::<ResourceRequest>() - 40usize];
["Alignment of ResourceRequest"][::std::mem::align_of::<ResourceRequest>() - 8usize];
["Offset of field: ResourceRequest::path"]
[::std::mem::offset_of!(ResourceRequest, path) - 0usize];
["Offset of field: ResourceRequest::unk08"]
[::std::mem::offset_of!(ResourceRequest, unk08) - 8usize];
["Offset of field: ResourceRequest::unk10"]
[::std::mem::offset_of!(ResourceRequest, unk10) - 16usize];
["Offset of field: ResourceRequest::disablePreInitialization"]
[::std::mem::offset_of!(ResourceRequest, disablePreInitialization) - 17usize];
["Offset of field: ResourceRequest::disableImports"]
[::std::mem::offset_of!(ResourceRequest, disableImports) - 18usize];
["Offset of field: ResourceRequest::disablePostLoad"]
[::std::mem::offset_of!(ResourceRequest, disablePostLoad) - 19usize];
["Offset of field: ResourceRequest::unk14"]
[::std::mem::offset_of!(ResourceRequest, unk14) - 20usize];
["Offset of field: ResourceRequest::unk15"]
[::std::mem::offset_of!(ResourceRequest, unk15) - 21usize];
["Offset of field: ResourceRequest::unk16"]
[::std::mem::offset_of!(ResourceRequest, unk16) - 22usize];
["Offset of field: ResourceRequest::archiveHandle"]
[::std::mem::offset_of!(ResourceRequest, archiveHandle) - 24usize];
["Offset of field: ResourceRequest::unk1C"]
[::std::mem::offset_of!(ResourceRequest, unk1C) - 28usize];
["Offset of field: ResourceRequest::unk20"]
[::std::mem::offset_of!(ResourceRequest, unk20) - 32usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0ResourceRequest@RED4ext@@QEAA@UResourcePath@1@@Z"]
pub fn ResourceRequest_ResourceRequest(
this: *mut root::RED4ext::ResourceRequest,
aPath: root::RED4ext::ResourcePath,
);
}
impl ResourceRequest {
#[inline]
pub unsafe fn new(aPath: root::RED4ext::ResourcePath) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
ResourceRequest_ResourceRequest(__bindgen_tmp.as_mut_ptr(), aPath);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug)]
pub struct ResourceLoader {
pub tokens: root::RED4ext::HashMap<
root::RED4ext::ResourcePath,
root::RED4ext::WeakPtr<root::RED4ext::ResourceToken<root::RED4ext::CResource>>,
>,
pub failed: root::RED4ext::DynArray<
root::RED4ext::SharedPtr<root::RED4ext::ResourceToken<root::RED4ext::CResource>>,
>,
pub tokenLock: root::RED4ext::SharedSpinLock,
pub unk48: usize,
pub unk50: usize,
pub unk58: usize,
pub unk60: u8,
pub unk68: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub unk70: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ResourceLoader"][::std::mem::size_of::<ResourceLoader>() - 128usize];
["Alignment of ResourceLoader"][::std::mem::align_of::<ResourceLoader>() - 8usize];
["Offset of field: ResourceLoader::tokens"]
[::std::mem::offset_of!(ResourceLoader, tokens) - 0usize];
["Offset of field: ResourceLoader::failed"]
[::std::mem::offset_of!(ResourceLoader, failed) - 48usize];
["Offset of field: ResourceLoader::tokenLock"]
[::std::mem::offset_of!(ResourceLoader, tokenLock) - 64usize];
["Offset of field: ResourceLoader::unk48"]
[::std::mem::offset_of!(ResourceLoader, unk48) - 72usize];
["Offset of field: ResourceLoader::unk50"]
[::std::mem::offset_of!(ResourceLoader, unk50) - 80usize];
["Offset of field: ResourceLoader::unk58"]
[::std::mem::offset_of!(ResourceLoader, unk58) - 88usize];
["Offset of field: ResourceLoader::unk60"]
[::std::mem::offset_of!(ResourceLoader, unk60) - 96usize];
["Offset of field: ResourceLoader::unk68"]
[::std::mem::offset_of!(ResourceLoader, unk68) - 104usize];
["Offset of field: ResourceLoader::unk70"]
[::std::mem::offset_of!(ResourceLoader, unk70) - 120usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Get@ResourceLoader@RED4ext@@SAPEAU12@XZ"]
pub fn ResourceLoader_Get() -> *mut root::RED4ext::ResourceLoader;
}
impl Default for ResourceLoader {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl ResourceLoader {
#[inline]
pub unsafe fn Get() -> *mut root::RED4ext::ResourceLoader {
ResourceLoader_Get()
}
}
#[repr(C)]
#[derive(Debug)]
pub struct ResourceReference<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub path: root::RED4ext::ResourcePath,
pub token: root::RED4ext::SharedPtr<root::RED4ext::ResourceToken<T>>,
}
impl<T> Default for ResourceReference<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ResourceAsyncReference {
pub path: root::RED4ext::ResourcePath,
}
pub type Ref<T> = root::RED4ext::ResourceReference<T>;
pub type RaRef = root::RED4ext::ResourceAsyncReference;
pub mod curve {
#[allow(unused_imports)]
use self::super::super::super::root;
pub mod EInterpolationType {
pub type Type = u8;
pub const EIT_Constant: Type = 0;
pub const EIT_Linear: Type = 1;
pub const EIT_BezierQuadratic: Type = 2;
pub const EIT_BezierCubic: Type = 3;
pub const EIT_Hermite: Type = 4;
}
pub mod ESegmentsLinkType {
pub type Type = u8;
pub const ESLT_Normal: Type = 0;
pub const ESLT_Smooth: Type = 1;
pub const ESLT_SmoothSymmetric: Type = 2;
}
}
pub use self::super::super::root::RED4ext::curve::EInterpolationType::Type as curveEInterpolationType;
pub use self::super::super::root::RED4ext::curve::ESegmentsLinkType::Type as curveESegmentsLinkType;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CDateTime {
pub unk00: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CDateTime"][::std::mem::size_of::<CDateTime>() - 8usize];
["Alignment of CDateTime"][::std::mem::align_of::<CDateTime>() - 8usize];
["Offset of field: CDateTime::unk00"]
[::std::mem::offset_of!(CDateTime, unk00) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CGUID {
pub unk00: i64,
pub unk08: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CGUID"][::std::mem::size_of::<CGUID>() - 16usize];
["Alignment of CGUID"][::std::mem::align_of::<CGUID>() - 8usize];
["Offset of field: CGUID::unk00"][::std::mem::offset_of!(CGUID, unk00) - 0usize];
["Offset of field: CGUID::unk08"][::std::mem::offset_of!(CGUID, unk08) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CRUID {
pub unk00: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRUID"][::std::mem::size_of::<CRUID>() - 8usize];
["Alignment of CRUID"][::std::mem::align_of::<CRUID>() - 8usize];
["Offset of field: CRUID::unk00"][::std::mem::offset_of!(CRUID, unk00) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CRUIDRef {
pub unk00: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRUIDRef"][::std::mem::size_of::<CRUIDRef>() - 8usize];
["Alignment of CRUIDRef"][::std::mem::align_of::<CRUIDRef>() - 8usize];
["Offset of field: CRUIDRef::unk00"][::std::mem::offset_of!(CRUIDRef, unk00) - 0usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct TweakDBID {
pub __bindgen_anon_1: root::RED4ext::TweakDBID__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union TweakDBID__bindgen_ty_1 {
pub value: u64,
pub name: root::RED4ext::TweakDBID__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct TweakDBID__bindgen_ty_1__bindgen_ty_1 {
pub hash: u32,
pub length: u8,
pub tdbOffsetBE: [u8; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TweakDBID__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::size_of::<TweakDBID__bindgen_ty_1__bindgen_ty_1>() - 8usize];
["Alignment of TweakDBID__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::align_of::<TweakDBID__bindgen_ty_1__bindgen_ty_1>() - 1usize];
["Offset of field: TweakDBID__bindgen_ty_1__bindgen_ty_1::hash"]
[::std::mem::offset_of!(TweakDBID__bindgen_ty_1__bindgen_ty_1, hash) - 0usize];
["Offset of field: TweakDBID__bindgen_ty_1__bindgen_ty_1::length"]
[::std::mem::offset_of!(TweakDBID__bindgen_ty_1__bindgen_ty_1, length) - 4usize];
["Offset of field: TweakDBID__bindgen_ty_1__bindgen_ty_1::tdbOffsetBE"][::std::mem::offset_of!(
TweakDBID__bindgen_ty_1__bindgen_ty_1,
tdbOffsetBE
) - 5usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TweakDBID__bindgen_ty_1"]
[::std::mem::size_of::<TweakDBID__bindgen_ty_1>() - 8usize];
["Alignment of TweakDBID__bindgen_ty_1"]
[::std::mem::align_of::<TweakDBID__bindgen_ty_1>() - 1usize];
["Offset of field: TweakDBID__bindgen_ty_1::value"]
[::std::mem::offset_of!(TweakDBID__bindgen_ty_1, value) - 0usize];
["Offset of field: TweakDBID__bindgen_ty_1::name"]
[::std::mem::offset_of!(TweakDBID__bindgen_ty_1, name) - 0usize];
};
impl Default for TweakDBID__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TweakDBID"][::std::mem::size_of::<TweakDBID>() - 8usize];
["Alignment of TweakDBID"][::std::mem::align_of::<TweakDBID>() - 1usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?IsValid@TweakDBID@RED4ext@@QEBA_NXZ"]
pub fn TweakDBID_IsValid(this: *const root::RED4ext::TweakDBID) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?HasTDBOffset@TweakDBID@RED4ext@@QEBA_NXZ"]
pub fn TweakDBID_HasTDBOffset(this: *const root::RED4ext::TweakDBID) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ToTDBOffset@TweakDBID@RED4ext@@QEBAHXZ"]
pub fn TweakDBID_ToTDBOffset(this: *const root::RED4ext::TweakDBID) -> i32;
}
unsafe extern "C" {
#[link_name = "\u{1}?SetTDBOffset@TweakDBID@RED4ext@@QEAAXH@Z"]
pub fn TweakDBID_SetTDBOffset(this: *mut root::RED4ext::TweakDBID, aTDBOffset: i32);
}
unsafe extern "C" {
#[link_name = "\u{1}??0TweakDBID@RED4ext@@QEAA@V?$basic_string_view@DU?$char_traits@D@std@@@std@@@Z"]
pub fn TweakDBID_TweakDBID(
this: *mut root::RED4ext::TweakDBID,
aName: root::std::string_view,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0TweakDBID@RED4ext@@QEAA@AEBU01@V?$basic_string_view@DU?$char_traits@D@std@@@std@@@Z"]
pub fn TweakDBID_TweakDBID1(
this: *mut root::RED4ext::TweakDBID,
aBase: *const root::RED4ext::TweakDBID,
aName: root::std::string_view,
);
}
impl Default for TweakDBID {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl TweakDBID {
#[inline]
pub unsafe fn IsValid(&self) -> bool {
TweakDBID_IsValid(self)
}
#[inline]
pub unsafe fn HasTDBOffset(&self) -> bool {
TweakDBID_HasTDBOffset(self)
}
#[inline]
pub unsafe fn ToTDBOffset(&self) -> i32 {
TweakDBID_ToTDBOffset(self)
}
#[inline]
pub unsafe fn SetTDBOffset(&mut self, aTDBOffset: i32) {
TweakDBID_SetTDBOffset(self, aTDBOffset)
}
#[inline]
pub unsafe fn new(aName: root::std::string_view) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
TweakDBID_TweakDBID(__bindgen_tmp.as_mut_ptr(), aName);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(
aBase: *const root::RED4ext::TweakDBID,
aName: root::std::string_view,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
TweakDBID_TweakDBID1(__bindgen_tmp.as_mut_ptr(), aBase, aName);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ItemID {
pub tdbid: root::RED4ext::TweakDBID,
pub rngSeed: u32,
pub uniqueCounter: u16,
pub structure: u8,
pub flags: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ItemID"][::std::mem::size_of::<ItemID>() - 16usize];
["Alignment of ItemID"][::std::mem::align_of::<ItemID>() - 4usize];
["Offset of field: ItemID::tdbid"][::std::mem::offset_of!(ItemID, tdbid) - 0usize];
["Offset of field: ItemID::rngSeed"][::std::mem::offset_of!(ItemID, rngSeed) - 8usize];
["Offset of field: ItemID::uniqueCounter"]
[::std::mem::offset_of!(ItemID, uniqueCounter) - 12usize];
["Offset of field: ItemID::structure"]
[::std::mem::offset_of!(ItemID, structure) - 14usize];
["Offset of field: ItemID::flags"][::std::mem::offset_of!(ItemID, flags) - 15usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?IsValid@ItemID@RED4ext@@QEBA_NXZ"]
pub fn ItemID_IsValid(this: *const root::RED4ext::ItemID) -> bool;
}
impl Default for ItemID {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl ItemID {
#[inline]
pub unsafe fn IsValid(&self) -> bool {
ItemID_IsValid(self)
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct EditorObjectID {
pub unk00: i64,
pub unk08: i64,
pub unk10: i64,
pub unk18: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of EditorObjectID"][::std::mem::size_of::<EditorObjectID>() - 32usize];
["Alignment of EditorObjectID"][::std::mem::align_of::<EditorObjectID>() - 8usize];
["Offset of field: EditorObjectID::unk00"]
[::std::mem::offset_of!(EditorObjectID, unk00) - 0usize];
["Offset of field: EditorObjectID::unk08"]
[::std::mem::offset_of!(EditorObjectID, unk08) - 8usize];
["Offset of field: EditorObjectID::unk10"]
[::std::mem::offset_of!(EditorObjectID, unk10) - 16usize];
["Offset of field: EditorObjectID::unk18"]
[::std::mem::offset_of!(EditorObjectID, unk18) - 24usize];
};
#[repr(C)]
pub struct Variant {
pub type_: *const root::RED4ext::CBaseRTTIType,
pub __bindgen_anon_1: root::RED4ext::Variant__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union Variant__bindgen_ty_1 {
pub inlined: [u8; 16usize],
pub instance: root::RED4ext::ScriptInstance,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Variant__bindgen_ty_1"]
[::std::mem::size_of::<Variant__bindgen_ty_1>() - 16usize];
["Alignment of Variant__bindgen_ty_1"]
[::std::mem::align_of::<Variant__bindgen_ty_1>() - 8usize];
["Offset of field: Variant__bindgen_ty_1::inlined"]
[::std::mem::offset_of!(Variant__bindgen_ty_1, inlined) - 0usize];
["Offset of field: Variant__bindgen_ty_1::instance"]
[::std::mem::offset_of!(Variant__bindgen_ty_1, instance) - 0usize];
};
impl Default for Variant__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const Variant_InlineSize: u32 = 16;
pub const Variant_InlineAlignment: u32 = 8;
pub const Variant_InlineFlag: usize = 1;
unsafe extern "C" {
#[link_name = "\u{1}?TypeMask@Variant@RED4ext@@2_KB"]
pub static Variant_TypeMask: usize;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Variant"][::std::mem::size_of::<Variant>() - 24usize];
["Alignment of Variant"][::std::mem::align_of::<Variant>() - 8usize];
["Offset of field: Variant::type_"][::std::mem::offset_of!(Variant, type_) - 0usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?IsEmpty@Variant@RED4ext@@QEBA_NXZ"]
pub fn Variant_IsEmpty(this: *const root::RED4ext::Variant) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?IsInlined@Variant@RED4ext@@QEBA_NXZ"]
pub fn Variant_IsInlined(this: *const root::RED4ext::Variant) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetType@Variant@RED4ext@@QEBAPEAUCBaseRTTIType@2@XZ"]
pub fn Variant_GetType(
this: *const root::RED4ext::Variant,
) -> *mut root::RED4ext::CBaseRTTIType;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetDataPtr@Variant@RED4ext@@QEBAPEAXXZ"]
pub fn Variant_GetDataPtr(
this: *const root::RED4ext::Variant,
) -> root::RED4ext::ScriptInstance;
}
unsafe extern "C" {
#[link_name = "\u{1}?Init@Variant@RED4ext@@QEAA_NPEBUCBaseRTTIType@2@@Z"]
pub fn Variant_Init(
this: *mut root::RED4ext::Variant,
aType: *const root::RED4ext::CBaseRTTIType,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?Fill@Variant@RED4ext@@QEAA_NPEBUCBaseRTTIType@2@QEAX@Z"]
pub fn Variant_Fill(
this: *mut root::RED4ext::Variant,
aType: *const root::RED4ext::CBaseRTTIType,
aData: root::RED4ext::ScriptInstance,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?Extract@Variant@RED4ext@@QEAA_NPEAX@Z"]
pub fn Variant_Extract(
this: *mut root::RED4ext::Variant,
aBuffer: root::RED4ext::ScriptInstance,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?Free@Variant@RED4ext@@QEAAXXZ"]
pub fn Variant_Free(this: *mut root::RED4ext::Variant);
}
unsafe extern "C" {
#[link_name = "\u{1}?CanBeInlined@Variant@RED4ext@@SA_NPEBUCBaseRTTIType@2@@Z"]
pub fn Variant_CanBeInlined(aType: *const root::RED4ext::CBaseRTTIType) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}??0Variant@RED4ext@@QEAA@PEBUCBaseRTTIType@1@@Z"]
pub fn Variant_Variant(
this: *mut root::RED4ext::Variant,
aType: *const root::RED4ext::CBaseRTTIType,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0Variant@RED4ext@@QEAA@PEBUCBaseRTTIType@1@QEAX@Z"]
pub fn Variant_Variant1(
this: *mut root::RED4ext::Variant,
aType: *const root::RED4ext::CBaseRTTIType,
aData: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0Variant@RED4ext@@QEAA@UCName@1@@Z"]
pub fn Variant_Variant2(
this: *mut root::RED4ext::Variant,
aTypeName: root::RED4ext::CName,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0Variant@RED4ext@@QEAA@UCName@1@QEAX@Z"]
pub fn Variant_Variant3(
this: *mut root::RED4ext::Variant,
aTypeName: root::RED4ext::CName,
aData: root::RED4ext::ScriptInstance,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0Variant@RED4ext@@QEAA@AEBU01@@Z"]
pub fn Variant_Variant4(
this: *mut root::RED4ext::Variant,
aOther: *const root::RED4ext::Variant,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0Variant@RED4ext@@QEAA@$$QEAU01@@Z"]
pub fn Variant_Variant5(
this: *mut root::RED4ext::Variant,
aOther: *mut root::RED4ext::Variant,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??1Variant@RED4ext@@QEAA@XZ"]
pub fn Variant_Variant_destructor(this: *mut root::RED4ext::Variant);
}
impl Default for Variant {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Variant {
#[inline]
pub unsafe fn IsEmpty(&self) -> bool {
Variant_IsEmpty(self)
}
#[inline]
pub unsafe fn IsInlined(&self) -> bool {
Variant_IsInlined(self)
}
#[inline]
pub unsafe fn GetType(&self) -> *mut root::RED4ext::CBaseRTTIType {
Variant_GetType(self)
}
#[inline]
pub unsafe fn GetDataPtr(&self) -> root::RED4ext::ScriptInstance {
Variant_GetDataPtr(self)
}
#[inline]
pub unsafe fn Init(&mut self, aType: *const root::RED4ext::CBaseRTTIType) -> bool {
Variant_Init(self, aType)
}
#[inline]
pub unsafe fn Fill(
&mut self,
aType: *const root::RED4ext::CBaseRTTIType,
aData: root::RED4ext::ScriptInstance,
) -> bool {
Variant_Fill(self, aType, aData)
}
#[inline]
pub unsafe fn Extract(&mut self, aBuffer: root::RED4ext::ScriptInstance) -> bool {
Variant_Extract(self, aBuffer)
}
#[inline]
pub unsafe fn Free(&mut self) {
Variant_Free(self)
}
#[inline]
pub unsafe fn CanBeInlined(aType: *const root::RED4ext::CBaseRTTIType) -> bool {
Variant_CanBeInlined(aType)
}
#[inline]
pub unsafe fn new(aType: *const root::RED4ext::CBaseRTTIType) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
Variant_Variant(__bindgen_tmp.as_mut_ptr(), aType);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(
aType: *const root::RED4ext::CBaseRTTIType,
aData: root::RED4ext::ScriptInstance,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
Variant_Variant1(__bindgen_tmp.as_mut_ptr(), aType, aData);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new2(aTypeName: root::RED4ext::CName) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
Variant_Variant2(__bindgen_tmp.as_mut_ptr(), aTypeName);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new3(
aTypeName: root::RED4ext::CName,
aData: root::RED4ext::ScriptInstance,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
Variant_Variant3(__bindgen_tmp.as_mut_ptr(), aTypeName, aData);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new4(aOther: *const root::RED4ext::Variant) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
Variant_Variant4(__bindgen_tmp.as_mut_ptr(), aOther);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new5(aOther: *mut root::RED4ext::Variant) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
Variant_Variant5(__bindgen_tmp.as_mut_ptr(), aOther);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
Variant_Variant_destructor(self)
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct gamedataLocKeyWrapper {
pub primaryKey: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of gamedataLocKeyWrapper"]
[::std::mem::size_of::<gamedataLocKeyWrapper>() - 8usize];
["Alignment of gamedataLocKeyWrapper"]
[::std::mem::align_of::<gamedataLocKeyWrapper>() - 8usize];
["Offset of field: gamedataLocKeyWrapper::primaryKey"]
[::std::mem::offset_of!(gamedataLocKeyWrapper, primaryKey) - 0usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0gamedataLocKeyWrapper@RED4ext@@QEAA@XZ"]
pub fn gamedataLocKeyWrapper_gamedataLocKeyWrapper(
this: *mut root::RED4ext::gamedataLocKeyWrapper,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0gamedataLocKeyWrapper@RED4ext@@QEAA@_K@Z"]
pub fn gamedataLocKeyWrapper_gamedataLocKeyWrapper1(
this: *mut root::RED4ext::gamedataLocKeyWrapper,
aPrimaryKey: u64,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0gamedataLocKeyWrapper@RED4ext@@QEAA@PEBD@Z"]
pub fn gamedataLocKeyWrapper_gamedataLocKeyWrapper2(
this: *mut root::RED4ext::gamedataLocKeyWrapper,
aSecondaryKey: *const ::std::os::raw::c_char,
);
}
impl gamedataLocKeyWrapper {
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
gamedataLocKeyWrapper_gamedataLocKeyWrapper(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(aPrimaryKey: u64) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
gamedataLocKeyWrapper_gamedataLocKeyWrapper1(
__bindgen_tmp.as_mut_ptr(),
aPrimaryKey,
);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new2(aSecondaryKey: *const ::std::os::raw::c_char) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
gamedataLocKeyWrapper_gamedataLocKeyWrapper2(
__bindgen_tmp.as_mut_ptr(),
aSecondaryKey,
);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
pub struct LocalizationString {
pub unk00: i64,
pub unk08: root::RED4ext::CString,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of LocalizationString"][::std::mem::size_of::<LocalizationString>() - 40usize];
["Alignment of LocalizationString"]
[::std::mem::align_of::<LocalizationString>() - 8usize];
["Offset of field: LocalizationString::unk00"]
[::std::mem::offset_of!(LocalizationString, unk00) - 0usize];
["Offset of field: LocalizationString::unk08"]
[::std::mem::offset_of!(LocalizationString, unk08) - 8usize];
};
impl Default for LocalizationString {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct MessageResourcePath {
pub unk00: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of MessageResourcePath"][::std::mem::size_of::<MessageResourcePath>() - 8usize];
["Alignment of MessageResourcePath"]
[::std::mem::align_of::<MessageResourcePath>() - 8usize];
["Offset of field: MessageResourcePath::unk00"]
[::std::mem::offset_of!(MessageResourcePath, unk00) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct RuntimeEntityRef {
pub unk00: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RuntimeEntityRef"][::std::mem::size_of::<RuntimeEntityRef>() - 8usize];
["Alignment of RuntimeEntityRef"][::std::mem::align_of::<RuntimeEntityRef>() - 8usize];
["Offset of field: RuntimeEntityRef::unk00"]
[::std::mem::offset_of!(RuntimeEntityRef, unk00) - 0usize];
};
pub type NativeArray = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CurvePoint<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub point: f32,
pub value: T,
}
impl<T> Default for CurvePoint<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct CurveBuffer {
pub size: u32,
pub unk04: u32,
pub pointsOffset: u32,
pub valuesOffset: u32,
}
#[repr(C)]
#[derive(Debug)]
pub struct CurveData {
pub name: root::RED4ext::CName,
pub buffer: root::RED4ext::RawBuffer,
pub valueType: *mut root::RED4ext::CBaseRTTIType,
pub interpolationType: root::RED4ext::curve::EInterpolationType::Type,
pub linkType: root::RED4ext::curve::ESegmentsLinkType::Type,
}
impl Default for CurveData {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ScriptRef<T> {
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
pub unk00: [u8; 16usize],
pub innerType: *mut root::RED4ext::CBaseRTTIType,
pub ref_: *mut T,
pub hash: root::RED4ext::CName,
}
impl<T> Default for ScriptRef<T> {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Mutex {
pub m_cs: root::CRITICAL_SECTION,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Mutex"][::std::mem::size_of::<Mutex>() - 40usize];
["Alignment of Mutex"][::std::mem::align_of::<Mutex>() - 8usize];
["Offset of field: Mutex::m_cs"][::std::mem::offset_of!(Mutex, m_cs) - 0usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Lock@Mutex@RED4ext@@QEAAXXZ"]
pub fn Mutex_Lock(this: *mut root::RED4ext::Mutex);
}
unsafe extern "C" {
#[link_name = "\u{1}?Unlock@Mutex@RED4ext@@QEAAXXZ"]
pub fn Mutex_Unlock(this: *mut root::RED4ext::Mutex);
}
unsafe extern "C" {
#[link_name = "\u{1}?lock@Mutex@RED4ext@@QEAAXXZ"]
pub fn Mutex_lock(this: *mut root::RED4ext::Mutex);
}
unsafe extern "C" {
#[link_name = "\u{1}?unlock@Mutex@RED4ext@@QEAAXXZ"]
pub fn Mutex_unlock(this: *mut root::RED4ext::Mutex);
}
unsafe extern "C" {
#[link_name = "\u{1}??0Mutex@RED4ext@@QEAA@XZ"]
pub fn Mutex_Mutex(this: *mut root::RED4ext::Mutex);
}
impl Default for Mutex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Mutex {
#[inline]
pub unsafe fn Lock(&mut self) {
Mutex_Lock(self)
}
#[inline]
pub unsafe fn Unlock(&mut self) {
Mutex_Unlock(self)
}
#[inline]
pub unsafe fn lock(&mut self) {
Mutex_lock(self)
}
#[inline]
pub unsafe fn unlock(&mut self) {
Mutex_unlock(self)
}
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
Mutex_Mutex(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
pub struct IRTTISystem__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct IRTTISystem {
pub vtable_: *const IRTTISystem__bindgen_vtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IRTTISystem"][::std::mem::size_of::<IRTTISystem>() - 8usize];
["Alignment of IRTTISystem"][::std::mem::align_of::<IRTTISystem>() - 8usize];
};
impl Default for IRTTISystem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
pub struct CRTTISystem {
pub _base: root::RED4ext::IRTTISystem,
pub unk8: i32,
pub types:
root::RED4ext::HashMap<root::RED4ext::CName, *mut root::RED4ext::CBaseRTTIType>,
pub typesByAsyncId: root::RED4ext::HashMap<u64, *mut root::RED4ext::CBaseRTTIType>,
pub typeAsyncIds: root::RED4ext::HashMap<root::RED4ext::CName, u32>,
pub funcs:
root::RED4ext::HashMap<root::RED4ext::CName, *mut root::RED4ext::CGlobalFunction>,
pub funcsByHash: root::RED4ext::HashMap<u64, *mut root::RED4ext::CGlobalFunction>,
pub unkF8:
root::RED4ext::HashMap<*mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void>,
pub unk130: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub unk140: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub scriptToNative: root::RED4ext::HashMap<root::RED4ext::CName, root::RED4ext::CName>,
pub nativeToScript: root::RED4ext::HashMap<root::RED4ext::CName, root::RED4ext::CName>,
pub strings: root::RED4ext::DynArray<root::RED4ext::CString>,
pub unk1C0: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub unk1D0: root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
pub unk1E0: root::RED4ext::Mutex,
pub typesLock: root::RED4ext::SharedSpinLock,
pub rttiRegistratorMutex: root::RED4ext::Mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CRTTISystem"][::std::mem::size_of::<CRTTISystem>() - 568usize];
["Alignment of CRTTISystem"][::std::mem::align_of::<CRTTISystem>() - 8usize];
["Offset of field: CRTTISystem::unk8"]
[::std::mem::offset_of!(CRTTISystem, unk8) - 8usize];
["Offset of field: CRTTISystem::types"]
[::std::mem::offset_of!(CRTTISystem, types) - 16usize];
["Offset of field: CRTTISystem::typesByAsyncId"]
[::std::mem::offset_of!(CRTTISystem, typesByAsyncId) - 64usize];
["Offset of field: CRTTISystem::typeAsyncIds"]
[::std::mem::offset_of!(CRTTISystem, typeAsyncIds) - 112usize];
["Offset of field: CRTTISystem::funcs"]
[::std::mem::offset_of!(CRTTISystem, funcs) - 160usize];
["Offset of field: CRTTISystem::funcsByHash"]
[::std::mem::offset_of!(CRTTISystem, funcsByHash) - 208usize];
["Offset of field: CRTTISystem::unkF8"]
[::std::mem::offset_of!(CRTTISystem, unkF8) - 256usize];
["Offset of field: CRTTISystem::unk130"]
[::std::mem::offset_of!(CRTTISystem, unk130) - 304usize];
["Offset of field: CRTTISystem::unk140"]
[::std::mem::offset_of!(CRTTISystem, unk140) - 320usize];
["Offset of field: CRTTISystem::scriptToNative"]
[::std::mem::offset_of!(CRTTISystem, scriptToNative) - 336usize];
["Offset of field: CRTTISystem::nativeToScript"]
[::std::mem::offset_of!(CRTTISystem, nativeToScript) - 384usize];
["Offset of field: CRTTISystem::strings"]
[::std::mem::offset_of!(CRTTISystem, strings) - 432usize];
["Offset of field: CRTTISystem::unk1C0"]
[::std::mem::offset_of!(CRTTISystem, unk1C0) - 448usize];
["Offset of field: CRTTISystem::unk1D0"]
[::std::mem::offset_of!(CRTTISystem, unk1D0) - 464usize];
["Offset of field: CRTTISystem::unk1E0"]
[::std::mem::offset_of!(CRTTISystem, unk1E0) - 480usize];
["Offset of field: CRTTISystem::typesLock"]
[::std::mem::offset_of!(CRTTISystem, typesLock) - 520usize];
["Offset of field: CRTTISystem::rttiRegistratorMutex"]
[::std::mem::offset_of!(CRTTISystem, rttiRegistratorMutex) - 528usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Get@CRTTISystem@RED4ext@@SAPEAU12@XZ"]
pub fn CRTTISystem_Get() -> *mut root::RED4ext::CRTTISystem;
}
unsafe extern "C" {
#[link_name = "\u{1}?RegisterType@CRTTISystem@RED4ext@@QEAAXPEAUCBaseRTTIType@2@@Z"]
pub fn CRTTISystem_RegisterType(
this: *mut root::RED4ext::CRTTISystem,
aType: *mut root::RED4ext::CBaseRTTIType,
);
}
impl Default for CRTTISystem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CRTTISystem {
#[inline]
pub unsafe fn Get() -> *mut root::RED4ext::CRTTISystem {
CRTTISystem_Get()
}
#[inline]
pub unsafe fn RegisterType(&mut self, aType: *mut root::RED4ext::CBaseRTTIType) {
CRTTISystem_RegisterType(self, aType)
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct RTTIRegistrator {
pub _address: u8,
}
pub type RTTIRegistrator_CallbackFunc = ::std::option::Option<unsafe extern "C" fn()>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of RTTIRegistrator"][::std::mem::size_of::<RTTIRegistrator>() - 1usize];
["Alignment of RTTIRegistrator"][::std::mem::align_of::<RTTIRegistrator>() - 1usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Add@RTTIRegistrator@RED4ext@@SAXP6AXXZ0_N@Z"]
pub fn RTTIRegistrator_Add(
aRegFunc: root::RED4ext::RTTIRegistrator_CallbackFunc,
aPostRegFunc: root::RED4ext::RTTIRegistrator_CallbackFunc,
aUnused: bool,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?GetNextId@RTTIRegistrator@RED4ext@@SA?BIXZ"]
pub fn RTTIRegistrator_GetNextId() -> u32;
}
impl RTTIRegistrator {
#[inline]
pub unsafe fn Add(
aRegFunc: root::RED4ext::RTTIRegistrator_CallbackFunc,
aPostRegFunc: root::RED4ext::RTTIRegistrator_CallbackFunc,
aUnused: bool,
) {
RTTIRegistrator_Add(aRegFunc, aPostRegFunc, aUnused)
}
#[inline]
pub unsafe fn GetNextId() -> u32 {
RTTIRegistrator_GetNextId()
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CCompiledCode {
pub unk00: u32,
pub unk04: u32,
pub bytecode: root::RED4ext::DataBuffer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CCompiledCode"][::std::mem::size_of::<CCompiledCode>() - 48usize];
["Alignment of CCompiledCode"][::std::mem::align_of::<CCompiledCode>() - 8usize];
["Offset of field: CCompiledCode::unk00"]
[::std::mem::offset_of!(CCompiledCode, unk00) - 0usize];
["Offset of field: CCompiledCode::unk04"]
[::std::mem::offset_of!(CCompiledCode, unk04) - 4usize];
["Offset of field: CCompiledCode::bytecode"]
[::std::mem::offset_of!(CCompiledCode, bytecode) - 8usize];
};
impl Default for CCompiledCode {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PoolRTTIFunctionAllocator {
_unused: [u8; 0],
}
#[repr(C)]
pub struct IFunction__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
#[derive(Debug)]
pub struct IFunction {
pub vtable_: *const IFunction__bindgen_vtable,
}
#[repr(C)]
pub struct IFunction_Invokable__bindgen_vtable {
pub IFunction_Invokable_sub_0: unsafe extern "C" fn(this: *mut IFunction_Invokable),
pub IFunction_Invokable_sub_8: unsafe extern "C" fn(this: *mut IFunction_Invokable),
pub IFunction_Invokable_Execute: unsafe extern "C" fn(
this: *mut IFunction_Invokable,
aInstance: root::RED4ext::ScriptInstance,
aFrame: *mut root::RED4ext::CStackFrame,
aResult: *mut ::std::os::raw::c_void,
aResultType: *const root::RED4ext::CBaseRTTIType,
),
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct IFunction_Invokable {
pub vtable_: *const IFunction_Invokable__bindgen_vtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IFunction_Invokable"][::std::mem::size_of::<IFunction_Invokable>() - 8usize];
["Alignment of IFunction_Invokable"]
[::std::mem::align_of::<IFunction_Invokable>() - 8usize];
};
impl Default for IFunction_Invokable {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IFunction"][::std::mem::size_of::<IFunction>() - 8usize];
["Alignment of IFunction"][::std::mem::align_of::<IFunction>() - 8usize];
};
impl Default for IFunction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type ScriptingFunction_t<T> = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut root::RED4ext::IScriptable,
arg2: *mut root::RED4ext::CStackFrame,
arg3: T,
arg4: i64,
),
>;
#[repr(C)]
#[derive(Debug)]
pub struct CBaseFunction {
pub _base: root::RED4ext::IFunction,
pub fullName: root::RED4ext::CName,
pub shortName: root::RED4ext::CName,
pub returnType: *mut root::RED4ext::CProperty,
pub unk20: i64,
pub params: root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
pub localVars: root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
pub unk48: root::RED4ext::HashMap<u64, *mut ::std::os::raw::c_void>,
pub bytecode: root::RED4ext::CCompiledCode,
pub flags: root::RED4ext::CBaseFunction_Flags,
pub unkAC: i32,
}
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct CBaseFunction_Flags {
pub _bitfield_align_1: [u16; 0],
pub _bitfield_1: root::__BindgenBitfieldUnit<[u8; 4usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseFunction_Flags"][::std::mem::size_of::<CBaseFunction_Flags>() - 4usize];
["Alignment of CBaseFunction_Flags"]
[::std::mem::align_of::<CBaseFunction_Flags>() - 4usize];
};
impl CBaseFunction_Flags {
#[inline]
pub fn isNative(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_isNative(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isNative_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isNative_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isStatic(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_isStatic(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isStatic_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
1usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isStatic_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isFinal(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_isFinal(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isFinal_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
2usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isFinal_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
2usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isEvent(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
}
#[inline]
pub fn set_isEvent(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isEvent_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
3usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isEvent_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
3usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isExec(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
}
#[inline]
pub fn set_isExec(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isExec_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
4usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isExec_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
4usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn hasUndefinedBody(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
}
#[inline]
pub fn set_hasUndefinedBody(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn hasUndefinedBody_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
5usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_hasUndefinedBody_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
5usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isTimer(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
}
#[inline]
pub fn set_isTimer(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isTimer_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
6usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isTimer_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
6usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isPrivate(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
}
#[inline]
pub fn set_isPrivate(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isPrivate_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
7usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isPrivate_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
7usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isProtected(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
}
#[inline]
pub fn set_isProtected(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isProtected_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
8usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isProtected_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
8usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isPublic(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
}
#[inline]
pub fn set_isPublic(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isPublic_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
9usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isPublic_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
9usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b10(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
}
#[inline]
pub fn set_b10(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b10_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
10usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_b10_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
10usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b11(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
}
#[inline]
pub fn set_b11(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b11_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
11usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_b11_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
11usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b12(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
}
#[inline]
pub fn set_b12(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn b12_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
12usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_b12_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
12usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isConst(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
}
#[inline]
pub fn set_isConst(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isConst_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
13usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isConst_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
13usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isQuest(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
}
#[inline]
pub fn set_isQuest(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isQuest_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
14usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isQuest_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
14usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn isThreadsafe(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
}
#[inline]
pub fn set_isThreadsafe(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn isThreadsafe_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
15usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_isThreadsafe_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
15usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn b16(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
}
#[inline]
pub fn set_b16(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(16usize, 16u8, val as u64)
}
}
#[inline]
pub unsafe fn b16_raw(this: *const Self) -> u32 {
unsafe {
::std::mem::transmute(<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
16usize,
16u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_b16_raw(this: *mut Self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<root::__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
16usize,
16u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
isNative: u32,
isStatic: u32,
isFinal: u32,
isEvent: u32,
isExec: u32,
hasUndefinedBody: u32,
isTimer: u32,
isPrivate: u32,
isProtected: u32,
isPublic: u32,
b10: u32,
b11: u32,
b12: u32,
isConst: u32,
isQuest: u32,
isThreadsafe: u32,
b16: u32,
) -> root::__BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: root::__BindgenBitfieldUnit<[u8; 4usize]> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let isNative: u32 = unsafe { ::std::mem::transmute(isNative) };
isNative as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let isStatic: u32 = unsafe { ::std::mem::transmute(isStatic) };
isStatic as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let isFinal: u32 = unsafe { ::std::mem::transmute(isFinal) };
isFinal as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let isEvent: u32 = unsafe { ::std::mem::transmute(isEvent) };
isEvent as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let isExec: u32 = unsafe { ::std::mem::transmute(isExec) };
isExec as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let hasUndefinedBody: u32 = unsafe { ::std::mem::transmute(hasUndefinedBody) };
hasUndefinedBody as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let isTimer: u32 = unsafe { ::std::mem::transmute(isTimer) };
isTimer as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let isPrivate: u32 = unsafe { ::std::mem::transmute(isPrivate) };
isPrivate as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let isProtected: u32 = unsafe { ::std::mem::transmute(isProtected) };
isProtected as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let isPublic: u32 = unsafe { ::std::mem::transmute(isPublic) };
isPublic as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let b10: u32 = unsafe { ::std::mem::transmute(b10) };
b10 as u64
});
__bindgen_bitfield_unit.set(11usize, 1u8, {
let b11: u32 = unsafe { ::std::mem::transmute(b11) };
b11 as u64
});
__bindgen_bitfield_unit.set(12usize, 1u8, {
let b12: u32 = unsafe { ::std::mem::transmute(b12) };
b12 as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let isConst: u32 = unsafe { ::std::mem::transmute(isConst) };
isConst as u64
});
__bindgen_bitfield_unit.set(14usize, 1u8, {
let isQuest: u32 = unsafe { ::std::mem::transmute(isQuest) };
isQuest as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let isThreadsafe: u32 = unsafe { ::std::mem::transmute(isThreadsafe) };
isThreadsafe as u64
});
__bindgen_bitfield_unit.set(16usize, 16u8, {
let b16: u32 = unsafe { ::std::mem::transmute(b16) };
b16 as u64
});
__bindgen_bitfield_unit
}
}
pub type CBaseFunction_Handler_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: root::RED4ext::ScriptInstance,
arg2: *mut root::RED4ext::CStackFrame,
arg3: *mut ::std::os::raw::c_void,
arg4: *mut root::RED4ext::CBaseRTTIType,
),
>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseFunction"][::std::mem::size_of::<CBaseFunction>() - 176usize];
["Alignment of CBaseFunction"][::std::mem::align_of::<CBaseFunction>() - 8usize];
["Offset of field: CBaseFunction::fullName"]
[::std::mem::offset_of!(CBaseFunction, fullName) - 8usize];
["Offset of field: CBaseFunction::shortName"]
[::std::mem::offset_of!(CBaseFunction, shortName) - 16usize];
["Offset of field: CBaseFunction::returnType"]
[::std::mem::offset_of!(CBaseFunction, returnType) - 24usize];
["Offset of field: CBaseFunction::unk20"]
[::std::mem::offset_of!(CBaseFunction, unk20) - 32usize];
["Offset of field: CBaseFunction::params"]
[::std::mem::offset_of!(CBaseFunction, params) - 40usize];
["Offset of field: CBaseFunction::localVars"]
[::std::mem::offset_of!(CBaseFunction, localVars) - 56usize];
["Offset of field: CBaseFunction::unk48"]
[::std::mem::offset_of!(CBaseFunction, unk48) - 72usize];
["Offset of field: CBaseFunction::bytecode"]
[::std::mem::offset_of!(CBaseFunction, bytecode) - 120usize];
["Offset of field: CBaseFunction::flags"]
[::std::mem::offset_of!(CBaseFunction, flags) - 168usize];
["Offset of field: CBaseFunction::unkAC"]
[::std::mem::offset_of!(CBaseFunction, unkAC) - 172usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Execute@CBaseFunction@RED4ext@@QEAA_NPEAUCStack@2@@Z"]
pub fn CBaseFunction_Execute(
this: *mut root::RED4ext::CBaseFunction,
aStack: *mut root::RED4ext::CStack,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?SetReturnType@CBaseFunction@RED4ext@@QEAA_NUCName@2@@Z"]
pub fn CBaseFunction_SetReturnType(
this: *mut root::RED4ext::CBaseFunction,
aType: root::RED4ext::CName,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?AddParam@CBaseFunction@RED4ext@@QEAA_NUCName@2@PEBD_N2@Z"]
pub fn CBaseFunction_AddParam(
this: *mut root::RED4ext::CBaseFunction,
aType: root::RED4ext::CName,
aName: *const ::std::os::raw::c_char,
aIsOut: bool,
aIsOptional: bool,
) -> bool;
}
impl Default for CBaseFunction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CBaseFunction {
#[inline]
pub unsafe fn Execute(&mut self, aStack: *mut root::RED4ext::CStack) -> bool {
CBaseFunction_Execute(self, aStack)
}
#[inline]
pub unsafe fn SetReturnType(&mut self, aType: root::RED4ext::CName) -> bool {
CBaseFunction_SetReturnType(self, aType)
}
#[inline]
pub unsafe fn AddParam(
&mut self,
aType: root::RED4ext::CName,
aName: *const ::std::os::raw::c_char,
aIsOut: bool,
aIsOptional: bool,
) -> bool {
CBaseFunction_AddParam(self, aType, aName, aIsOut, aIsOptional)
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CGlobalFunction {
pub _base: root::RED4ext::CBaseFunction,
pub regIndex: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CGlobalFunction"][::std::mem::size_of::<CGlobalFunction>() - 184usize];
["Alignment of CGlobalFunction"][::std::mem::align_of::<CGlobalFunction>() - 8usize];
["Offset of field: CGlobalFunction::regIndex"]
[::std::mem::offset_of!(CGlobalFunction, regIndex) - 176usize];
};
impl Default for CGlobalFunction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CClassFunction {
pub _base: root::RED4ext::CBaseFunction,
pub parent: *mut root::RED4ext::CClass,
pub regIndex: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CClassFunction"][::std::mem::size_of::<CClassFunction>() - 192usize];
["Alignment of CClassFunction"][::std::mem::align_of::<CClassFunction>() - 8usize];
["Offset of field: CClassFunction::parent"]
[::std::mem::offset_of!(CClassFunction, parent) - 176usize];
["Offset of field: CClassFunction::regIndex"]
[::std::mem::offset_of!(CClassFunction, regIndex) - 184usize];
};
impl Default for CClassFunction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CClassStaticFunction {
pub _base: root::RED4ext::CClassFunction,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CClassStaticFunction"]
[::std::mem::size_of::<CClassStaticFunction>() - 192usize];
["Alignment of CClassStaticFunction"]
[::std::mem::align_of::<CClassStaticFunction>() - 8usize];
};
impl Default for CClassStaticFunction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CScriptedFunction {
pub _base: root::RED4ext::CBaseFunction,
pub parent: *mut root::RED4ext::CClass,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CScriptedFunction"][::std::mem::size_of::<CScriptedFunction>() - 184usize];
["Alignment of CScriptedFunction"]
[::std::mem::align_of::<CScriptedFunction>() - 8usize];
["Offset of field: CScriptedFunction::parent"]
[::std::mem::offset_of!(CScriptedFunction, parent) - 176usize];
};
impl Default for CScriptedFunction {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CStackType {
pub type_: *mut root::RED4ext::CBaseRTTIType,
pub value: root::RED4ext::ScriptInstance,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CStackType"][::std::mem::size_of::<CStackType>() - 16usize];
["Alignment of CStackType"][::std::mem::align_of::<CStackType>() - 8usize];
["Offset of field: CStackType::type_"]
[::std::mem::offset_of!(CStackType, type_) - 0usize];
["Offset of field: CStackType::value"]
[::std::mem::offset_of!(CStackType, value) - 8usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0CStackType@RED4ext@@QEAA@PEAUCBaseRTTIType@1@PEAX@Z"]
pub fn CStackType_CStackType(
this: *mut root::RED4ext::CStackType,
aType: *mut root::RED4ext::CBaseRTTIType,
aValue: root::RED4ext::ScriptInstance,
);
}
impl Default for CStackType {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CStackType {
#[inline]
pub unsafe fn new(
aType: *mut root::RED4ext::CBaseRTTIType,
aValue: root::RED4ext::ScriptInstance,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CStackType_CStackType(__bindgen_tmp.as_mut_ptr(), aType, aValue);
__bindgen_tmp.assume_init()
}
}
pub type StackArgs_t = root::__BindgenOpaqueArray<u64, 3usize>;
#[repr(C)]
pub struct IStack__bindgen_vtable {}
#[repr(C)]
#[derive(Debug)]
pub struct IStack {
pub vtable_: *const IStack__bindgen_vtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IStack"][::std::mem::size_of::<IStack>() - 8usize];
["Alignment of IStack"][::std::mem::align_of::<IStack>() - 8usize];
};
impl Default for IStack {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CBaseStack {
pub _base: root::RED4ext::IStack,
pub unk08: i64,
pub unk10: *mut ::std::os::raw::c_void,
pub context18: *mut root::RED4ext::IScriptable,
pub context20: *mut root::RED4ext::IScriptable,
pub unk28: *mut root::RED4ext::CClass,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CBaseStack"][::std::mem::size_of::<CBaseStack>() - 48usize];
["Alignment of CBaseStack"][::std::mem::align_of::<CBaseStack>() - 8usize];
["Offset of field: CBaseStack::unk08"]
[::std::mem::offset_of!(CBaseStack, unk08) - 8usize];
["Offset of field: CBaseStack::unk10"]
[::std::mem::offset_of!(CBaseStack, unk10) - 16usize];
["Offset of field: CBaseStack::context18"]
[::std::mem::offset_of!(CBaseStack, context18) - 24usize];
["Offset of field: CBaseStack::context20"]
[::std::mem::offset_of!(CBaseStack, context20) - 32usize];
["Offset of field: CBaseStack::unk28"]
[::std::mem::offset_of!(CBaseStack, unk28) - 40usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?GetContext@CBaseStack@RED4ext@@QEBAPEAUIScriptable@2@XZ"]
pub fn CBaseStack_GetContext(
this: *const root::RED4ext::CBaseStack,
) -> *mut root::RED4ext::IScriptable;
}
unsafe extern "C" {
#[link_name = "\u{1}??0CBaseStack@RED4ext@@IEAA@PEAUIScriptable@1@@Z"]
pub fn CBaseStack_CBaseStack(
this: *mut root::RED4ext::CBaseStack,
aContext: *mut root::RED4ext::IScriptable,
);
}
impl Default for CBaseStack {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CBaseStack {
#[inline]
pub unsafe fn GetContext(&self) -> *mut root::RED4ext::IScriptable {
CBaseStack_GetContext(self)
}
#[inline]
pub unsafe fn new(aContext: *mut root::RED4ext::IScriptable) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CBaseStack_CBaseStack(__bindgen_tmp.as_mut_ptr(), aContext);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CStack {
pub _base: root::RED4ext::CBaseStack,
pub args: *mut root::RED4ext::CStackType,
pub argsCount: u32,
pub result: *mut root::RED4ext::CStackType,
pub pad48: [u8; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CStack"][::std::mem::size_of::<CStack>() - 88usize];
["Alignment of CStack"][::std::mem::align_of::<CStack>() - 8usize];
["Offset of field: CStack::args"][::std::mem::offset_of!(CStack, args) - 48usize];
["Offset of field: CStack::argsCount"]
[::std::mem::offset_of!(CStack, argsCount) - 56usize];
["Offset of field: CStack::result"][::std::mem::offset_of!(CStack, result) - 64usize];
["Offset of field: CStack::pad48"][::std::mem::offset_of!(CStack, pad48) - 72usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0CStack@RED4ext@@QEAA@PEAXPEAUCStackType@1@I1@Z"]
pub fn CStack_CStack(
this: *mut root::RED4ext::CStack,
aContext: root::RED4ext::ScriptInstance,
aArgs: *mut root::RED4ext::CStackType,
aArgsCount: u32,
aResult: *mut root::RED4ext::CStackType,
);
}
impl Default for CStack {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CStack {
#[inline]
pub unsafe fn new(
aContext: root::RED4ext::ScriptInstance,
aArgs: *mut root::RED4ext::CStackType,
aArgsCount: u32,
aResult: *mut root::RED4ext::CStackType,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CStack_CStack(
__bindgen_tmp.as_mut_ptr(),
aContext,
aArgs,
aArgsCount,
aResult,
);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug)]
pub struct CScriptStack {
pub _base: root::RED4ext::CBaseStack,
pub args: *mut u8,
pub value: root::RED4ext::ScriptInstance,
pub type_: *mut root::RED4ext::CBaseRTTIType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CScriptStack"][::std::mem::size_of::<CScriptStack>() - 72usize];
["Alignment of CScriptStack"][::std::mem::align_of::<CScriptStack>() - 8usize];
["Offset of field: CScriptStack::args"]
[::std::mem::offset_of!(CScriptStack, args) - 48usize];
["Offset of field: CScriptStack::value"]
[::std::mem::offset_of!(CScriptStack, value) - 56usize];
["Offset of field: CScriptStack::type_"]
[::std::mem::offset_of!(CScriptStack, type_) - 64usize];
};
impl Default for CScriptStack {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CStackFrame {
pub code: *mut ::std::os::raw::c_char,
pub func: *mut root::RED4ext::CBaseFunction,
pub localVars: *mut ::std::os::raw::c_void,
pub params: *mut ::std::os::raw::c_void,
pub unk20: i64,
pub unk28: i64,
pub data: *mut ::std::os::raw::c_void,
pub dataType: *mut root::RED4ext::CBaseRTTIType,
pub context: *mut root::RED4ext::IScriptable,
pub parent: *mut root::RED4ext::CStackFrame,
pub unk50: i16,
pub unk58: i64,
pub paramFlags: u16,
pub currentParam: u8,
pub useDirectData: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of CStackFrame"][::std::mem::size_of::<CStackFrame>() - 104usize];
["Alignment of CStackFrame"][::std::mem::align_of::<CStackFrame>() - 8usize];
["Offset of field: CStackFrame::code"]
[::std::mem::offset_of!(CStackFrame, code) - 0usize];
["Offset of field: CStackFrame::func"]
[::std::mem::offset_of!(CStackFrame, func) - 8usize];
["Offset of field: CStackFrame::localVars"]
[::std::mem::offset_of!(CStackFrame, localVars) - 16usize];
["Offset of field: CStackFrame::params"]
[::std::mem::offset_of!(CStackFrame, params) - 24usize];
["Offset of field: CStackFrame::unk20"]
[::std::mem::offset_of!(CStackFrame, unk20) - 32usize];
["Offset of field: CStackFrame::unk28"]
[::std::mem::offset_of!(CStackFrame, unk28) - 40usize];
["Offset of field: CStackFrame::data"]
[::std::mem::offset_of!(CStackFrame, data) - 48usize];
["Offset of field: CStackFrame::dataType"]
[::std::mem::offset_of!(CStackFrame, dataType) - 56usize];
["Offset of field: CStackFrame::context"]
[::std::mem::offset_of!(CStackFrame, context) - 64usize];
["Offset of field: CStackFrame::parent"]
[::std::mem::offset_of!(CStackFrame, parent) - 72usize];
["Offset of field: CStackFrame::unk50"]
[::std::mem::offset_of!(CStackFrame, unk50) - 80usize];
["Offset of field: CStackFrame::unk58"]
[::std::mem::offset_of!(CStackFrame, unk58) - 88usize];
["Offset of field: CStackFrame::paramFlags"]
[::std::mem::offset_of!(CStackFrame, paramFlags) - 96usize];
["Offset of field: CStackFrame::currentParam"]
[::std::mem::offset_of!(CStackFrame, currentParam) - 98usize];
["Offset of field: CStackFrame::useDirectData"]
[::std::mem::offset_of!(CStackFrame, useDirectData) - 99usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0CStackFrame@RED4ext@@QEAA@PEAUIScriptable@1@PEADPEAX@Z"]
pub fn CStackFrame_CStackFrame(
this: *mut root::RED4ext::CStackFrame,
aContext: *mut root::RED4ext::IScriptable,
aCode: *mut ::std::os::raw::c_char,
aUnk: *mut ::std::os::raw::c_void,
);
}
impl Default for CStackFrame {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl CStackFrame {
#[inline]
pub unsafe fn new(
aContext: *mut root::RED4ext::IScriptable,
aCode: *mut ::std::os::raw::c_char,
aUnk: *mut ::std::os::raw::c_void,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
CStackFrame_CStackFrame(__bindgen_tmp.as_mut_ptr(), aContext, aCode, aUnk);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct OpcodeHandlers {
pub _address: u8,
}
pub type OpcodeHandlers_Handler_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut root::RED4ext::IScriptable,
arg2: *mut root::RED4ext::CStackFrame,
arg3: *mut ::std::os::raw::c_void,
arg4: *mut ::std::os::raw::c_void,
),
>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of OpcodeHandlers"][::std::mem::size_of::<OpcodeHandlers>() - 1usize];
["Alignment of OpcodeHandlers"][::std::mem::align_of::<OpcodeHandlers>() - 1usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?Get@OpcodeHandlers@RED4ext@@SAP6AXPEAUIScriptable@2@PEAUCStackFrame@2@PEAX2@ZE@Z"]
pub fn OpcodeHandlers_Get(aOpcode: u8) -> root::RED4ext::OpcodeHandlers_Handler_t;
}
unsafe extern "C" {
#[link_name = "\u{1}?Run@OpcodeHandlers@RED4ext@@SAXEPEAUIScriptable@2@PEAUCStackFrame@2@PEAX2@Z"]
pub fn OpcodeHandlers_Run(
aOpcode: u8,
arg1: *mut root::RED4ext::IScriptable,
arg2: *mut root::RED4ext::CStackFrame,
arg3: *mut ::std::os::raw::c_void,
arg4: *mut ::std::os::raw::c_void,
);
}
impl OpcodeHandlers {
#[inline]
pub unsafe fn Get(aOpcode: u8) -> root::RED4ext::OpcodeHandlers_Handler_t {
OpcodeHandlers_Get(aOpcode)
}
#[inline]
pub unsafe fn Run(
aOpcode: u8,
arg1: *mut root::RED4ext::IScriptable,
arg2: *mut root::RED4ext::CStackFrame,
arg3: *mut ::std::os::raw::c_void,
arg4: *mut ::std::os::raw::c_void,
) {
OpcodeHandlers_Run(aOpcode, arg1, arg2, arg3, arg4)
}
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteFunction@RED4ext@@YA_NPEAXPEAUCBaseFunction@1@0@Z"]
pub fn ExecuteFunction(
aInstance: root::RED4ext::ScriptInstance,
aFunc: *mut root::RED4ext::CBaseFunction,
aOut: *mut ::std::os::raw::c_void,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteFunction@RED4ext@@YA_NPEAXPEAUCBaseFunction@1@0AEAV?$vector@UCStackType@RED4ext@@V?$allocator@UCStackType@RED4ext@@@std@@@std@@@Z"]
pub fn ExecuteFunction1(
aInstance: root::RED4ext::ScriptInstance,
aFunc: *mut root::RED4ext::CBaseFunction,
aOut: *mut ::std::os::raw::c_void,
aArgs: *mut root::RED4ext::StackArgs_t,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteFunction@RED4ext@@YA_NPEAUCClass@1@PEAUCBaseFunction@1@PEAXAEAV?$vector@UCStackType@RED4ext@@V?$allocator@UCStackType@RED4ext@@@std@@@std@@@Z"]
pub fn ExecuteFunction2(
aContext: *mut root::RED4ext::CClass,
aFunc: *mut root::RED4ext::CBaseFunction,
aOut: *mut ::std::os::raw::c_void,
aArgs: *mut root::RED4ext::StackArgs_t,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteFunction@RED4ext@@YA_NPEAUCClass@1@UCName@1@PEAXAEAV?$vector@UCStackType@RED4ext@@V?$allocator@UCStackType@RED4ext@@@std@@@std@@@Z"]
pub fn ExecuteFunction3(
aContext: *mut root::RED4ext::CClass,
aFunc: root::RED4ext::CName,
aOut: *mut ::std::os::raw::c_void,
aArgs: *mut root::RED4ext::StackArgs_t,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteFunction@RED4ext@@YA_NUCName@1@0PEAXAEAV?$vector@UCStackType@RED4ext@@V?$allocator@UCStackType@RED4ext@@@std@@@std@@@Z"]
pub fn ExecuteFunction4(
aContext: root::RED4ext::CName,
aFunc: root::RED4ext::CName,
aOut: *mut ::std::os::raw::c_void,
aArgs: *mut root::RED4ext::StackArgs_t,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteGlobalFunction@RED4ext@@YA_NPEAUCClass@1@UCName@1@PEAXAEAV?$vector@UCStackType@RED4ext@@V?$allocator@UCStackType@RED4ext@@@std@@@std@@@Z"]
pub fn ExecuteGlobalFunction(
aContext: *mut root::RED4ext::CClass,
aFunc: root::RED4ext::CName,
aOut: *mut ::std::os::raw::c_void,
aArgs: *mut root::RED4ext::StackArgs_t,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteGlobalFunction@RED4ext@@YA_NUCName@1@0PEAXAEAV?$vector@UCStackType@RED4ext@@V?$allocator@UCStackType@RED4ext@@@std@@@std@@@Z"]
pub fn ExecuteGlobalFunction1(
aContext: root::RED4ext::CName,
aFunc: root::RED4ext::CName,
aOut: *mut ::std::os::raw::c_void,
aArgs: *mut root::RED4ext::StackArgs_t,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ExecuteGlobalFunction@RED4ext@@YA_NUCName@1@PEAXAEAV?$vector@UCStackType@RED4ext@@V?$allocator@UCStackType@RED4ext@@@std@@@std@@@Z"]
pub fn ExecuteGlobalFunction2(
aFunc: root::RED4ext::CName,
aOut: *mut ::std::os::raw::c_void,
aArgs: *mut root::RED4ext::StackArgs_t,
) -> bool;
}
pub type SharedMutex = root::RED4ext::SharedSpinLock;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Color {
pub Red: u8,
pub Green: u8,
pub Blue: u8,
pub Alpha: u8,
}
pub const Color_NAME: &[u8; 6] = b"Color\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@Color@RED4ext@@2QEBDEB"]
pub static Color_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Color"][::std::mem::size_of::<Color>() - 4usize];
["Alignment of Color"][::std::mem::align_of::<Color>() - 1usize];
["Offset of field: Color::Red"][::std::mem::offset_of!(Color, Red) - 0usize];
["Offset of field: Color::Green"][::std::mem::offset_of!(Color, Green) - 1usize];
["Offset of field: Color::Blue"][::std::mem::offset_of!(Color, Blue) - 2usize];
["Offset of field: Color::Alpha"][::std::mem::offset_of!(Color, Alpha) - 3usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct EulerAngles {
pub Roll: f32,
pub Pitch: f32,
pub Yaw: f32,
}
pub const EulerAngles_NAME: &[u8; 12] = b"EulerAngles\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@EulerAngles@RED4ext@@2QEBDEB"]
pub static EulerAngles_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of EulerAngles"][::std::mem::size_of::<EulerAngles>() - 12usize];
["Alignment of EulerAngles"][::std::mem::align_of::<EulerAngles>() - 4usize];
["Offset of field: EulerAngles::Roll"]
[::std::mem::offset_of!(EulerAngles, Roll) - 0usize];
["Offset of field: EulerAngles::Pitch"]
[::std::mem::offset_of!(EulerAngles, Pitch) - 4usize];
["Offset of field: EulerAngles::Yaw"]
[::std::mem::offset_of!(EulerAngles, Yaw) - 8usize];
};
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct Quaternion {
pub i: f32,
pub j: f32,
pub k: f32,
pub r: f32,
}
pub const Quaternion_NAME: &[u8; 11] = b"Quaternion\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@Quaternion@RED4ext@@2QEBDEB"]
pub static Quaternion_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Quaternion"][::std::mem::size_of::<Quaternion>() - 16usize];
["Alignment of Quaternion"][::std::mem::align_of::<Quaternion>() - 16usize];
["Offset of field: Quaternion::i"][::std::mem::offset_of!(Quaternion, i) - 0usize];
["Offset of field: Quaternion::j"][::std::mem::offset_of!(Quaternion, j) - 4usize];
["Offset of field: Quaternion::k"][::std::mem::offset_of!(Quaternion, k) - 8usize];
["Offset of field: Quaternion::r"][::std::mem::offset_of!(Quaternion, r) - 12usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Vector2 {
pub X: f32,
pub Y: f32,
}
pub const Vector2_NAME: &[u8; 8] = b"Vector2\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@Vector2@RED4ext@@2QEBDEB"]
pub static Vector2_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Vector2"][::std::mem::size_of::<Vector2>() - 8usize];
["Alignment of Vector2"][::std::mem::align_of::<Vector2>() - 4usize];
["Offset of field: Vector2::X"][::std::mem::offset_of!(Vector2, X) - 0usize];
["Offset of field: Vector2::Y"][::std::mem::offset_of!(Vector2, Y) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Vector3 {
pub X: f32,
pub Y: f32,
pub Z: f32,
}
pub const Vector3_NAME: &[u8; 8] = b"Vector3\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@Vector3@RED4ext@@2QEBDEB"]
pub static Vector3_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of Vector3"][::std::mem::size_of::<Vector3>() - 12usize];
["Alignment of Vector3"][::std::mem::align_of::<Vector3>() - 4usize];
["Offset of field: Vector3::X"][::std::mem::offset_of!(Vector3, X) - 0usize];
["Offset of field: Vector3::Y"][::std::mem::offset_of!(Vector3, Y) - 4usize];
["Offset of field: Vector3::Z"][::std::mem::offset_of!(Vector3, Z) - 8usize];
};
pub mod game {
#[allow(unused_imports)]
use self::super::super::super::root;
pub mod data {
#[allow(unused_imports)]
use self::super::super::super::super::root;
#[repr(C)]
pub struct TweakDBRecord {
pub _base: root::RED4ext::IScriptable,
pub recordID: root::RED4ext::TweakDBID,
}
pub const TweakDBRecord_NAME: &[u8; 22] = b"gamedataTweakDBRecord\0";
pub const TweakDBRecord_ALIAS: &[u8; 14] = b"TweakDBRecord\0";
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TweakDBRecord"][::std::mem::size_of::<TweakDBRecord>() - 72usize];
["Alignment of TweakDBRecord"]
[::std::mem::align_of::<TweakDBRecord>() - 8usize];
["Offset of field: TweakDBRecord::recordID"]
[::std::mem::offset_of!(TweakDBRecord, recordID) - 64usize];
};
impl Default for TweakDBRecord {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct IScriptableSystem {
pub _base: root::RED4ext::IScriptable,
}
pub const IScriptableSystem_NAME: &[u8; 22] = b"gameIScriptableSystem\0";
pub const IScriptableSystem_ALIAS: &[u8; 18] = b"IScriptableSystem\0";
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of IScriptableSystem"][::std::mem::size_of::<IScriptableSystem>() - 64usize];
["Alignment of IScriptableSystem"]
[::std::mem::align_of::<IScriptableSystem>() - 8usize];
};
impl Default for IScriptableSystem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct ScriptableSystem {
pub _base: root::RED4ext::game::IScriptableSystem,
pub unk40: [u8; 1264usize],
}
pub const ScriptableSystem_NAME: &[u8; 21] = b"gameScriptableSystem\0";
pub const ScriptableSystem_ALIAS: &[u8; 17] = b"ScriptableSystem\0";
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ScriptableSystem"][::std::mem::size_of::<ScriptableSystem>() - 1328usize];
["Alignment of ScriptableSystem"]
[::std::mem::align_of::<ScriptableSystem>() - 8usize];
["Offset of field: ScriptableSystem::unk40"]
[::std::mem::offset_of!(ScriptableSystem, unk40) - 64usize];
};
impl Default for ScriptableSystem {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
}
pub type gamedataTweakDBRecord = root::RED4ext::game::data::TweakDBRecord;
pub type TweakDBRecord = root::RED4ext::game::data::TweakDBRecord;
pub mod SortedArray_Flags {
pub type Type = i32;
pub const NotSorted: Type = 0;
}
pub type SortedUniqueArray = u8;
#[repr(C)]
pub struct TweakDB {
pub staticFlatDataBuffer: usize,
pub unk08: u64,
pub unkF0: *mut ::std::os::raw::c_void,
pub unkF8: *mut ::std::os::raw::c_void,
pub mutex00: root::RED4ext::SharedSpinLock,
pub mutex01: root::RED4ext::SharedSpinLock,
pub unk28: *mut ::std::os::raw::c_void,
pub unk30: *mut ::std::os::raw::c_void,
pub unk38: bool,
pub flats: root::__BindgenOpaqueArray<u64, 3usize>,
pub recordsByID: root::RED4ext::HashMap<
root::RED4ext::TweakDBID,
root::RED4ext::Handle<root::RED4ext::IScriptable>,
>,
pub recordsByType: root::RED4ext::HashMap<
*mut root::RED4ext::CBaseRTTIType,
root::RED4ext::DynArray<root::RED4ext::Handle<root::RED4ext::IScriptable>>,
>,
pub queries: root::RED4ext::Map<
root::RED4ext::TweakDBID,
root::RED4ext::DynArray<root::RED4ext::TweakDBID>,
>,
pub groups:
root::RED4ext::Map<root::RED4ext::TweakDBID, root::RED4ext::TweakDB_GroupTag::Type>,
pub defaultValues:
root::RED4ext::HashMap<root::RED4ext::CName, *mut root::RED4ext::TweakDB_FlatValue>,
pub unk138: root::RED4ext::DynArray<root::RED4ext::CString>,
pub flatDataBuffer: usize,
pub flatDataBufferCapacity: u32,
pub flatDataBufferEnd: usize,
pub unk160: u8,
pub unk164: u32,
}
pub mod TweakDB_GroupTag {
pub type Type = i8;
pub const None: Type = 0;
pub const Abstract: Type = 1;
pub const NotQueryable: Type = 2;
pub const CPO: Type = 4;
pub const Debug: Type = 8;
}
#[repr(C)]
pub struct TweakDB_FlatValue__bindgen_vtable {
pub TweakDB_FlatValue_GetValueOffset_array_TweakDBID: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_TweakDBID: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_array_Quaternion: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_Quaternion: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_array_EulerAngles: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_EulerAngles: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_array_Vector3: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_Vector3: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_Vector2: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_Vector2: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_Color: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_Color: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_gamedataLocKeyWrapper:
unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_gamedataLocKeyWrapper:
unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_raRefCResource: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_raRefCResource: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_array_CName: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_CName: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_Bool: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_Bool: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_String: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_String: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_Float: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_Float: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValueOffset_array_Int32: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
)
-> bool,
pub TweakDB_FlatValue_GetValueOffset_Int32: unsafe extern "C" fn(
this: *const TweakDB_FlatValue,
aFlat: *mut root::RED4ext::TweakDBID,
) -> bool,
pub TweakDB_FlatValue_GetValue:
unsafe extern "C" fn(this: *mut TweakDB_FlatValue) -> root::RED4ext::CStackType,
pub TweakDB_FlatValue_GetTypeName: unsafe extern "C" fn(
this: *mut TweakDB_FlatValue,
aName: *mut root::RED4ext::CName,
)
-> *mut root::RED4ext::CName,
pub TweakDB_FlatValue_GetDataPtr:
unsafe extern "C" fn(this: *mut TweakDB_FlatValue) -> *mut ::std::os::raw::c_void,
}
#[repr(C)]
#[derive(Debug)]
pub struct TweakDB_FlatValue {
pub vtable_: *const TweakDB_FlatValue__bindgen_vtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TweakDB_FlatValue"][::std::mem::size_of::<TweakDB_FlatValue>() - 8usize];
["Alignment of TweakDB_FlatValue"]
[::std::mem::align_of::<TweakDB_FlatValue>() - 8usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?ToTDBOffset@FlatValue@TweakDB@RED4ext@@QEBAHXZ"]
pub fn TweakDB_FlatValue_ToTDBOffset(
this: *const root::RED4ext::TweakDB_FlatValue,
) -> i32;
}
impl Default for TweakDB_FlatValue {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl TweakDB_FlatValue {
#[inline]
pub unsafe fn ToTDBOffset(&self) -> i32 {
TweakDB_FlatValue_ToTDBOffset(self)
}
}
pub type TweakDB_QuaternionFlatValue = root::__BindgenOpaqueArray<u128, 2usize>;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of TweakDB"][::std::mem::size_of::<TweakDB>() - 360usize];
["Alignment of TweakDB"][::std::mem::align_of::<TweakDB>() - 8usize];
["Offset of field: TweakDB::staticFlatDataBuffer"]
[::std::mem::offset_of!(TweakDB, staticFlatDataBuffer) - 0usize];
["Offset of field: TweakDB::unk08"][::std::mem::offset_of!(TweakDB, unk08) - 8usize];
["Offset of field: TweakDB::unkF0"][::std::mem::offset_of!(TweakDB, unkF0) - 16usize];
["Offset of field: TweakDB::unkF8"][::std::mem::offset_of!(TweakDB, unkF8) - 24usize];
["Offset of field: TweakDB::mutex00"]
[::std::mem::offset_of!(TweakDB, mutex00) - 32usize];
["Offset of field: TweakDB::mutex01"]
[::std::mem::offset_of!(TweakDB, mutex01) - 33usize];
["Offset of field: TweakDB::unk28"][::std::mem::offset_of!(TweakDB, unk28) - 40usize];
["Offset of field: TweakDB::unk30"][::std::mem::offset_of!(TweakDB, unk30) - 48usize];
["Offset of field: TweakDB::unk38"][::std::mem::offset_of!(TweakDB, unk38) - 56usize];
["Offset of field: TweakDB::flats"][::std::mem::offset_of!(TweakDB, flats) - 64usize];
["Offset of field: TweakDB::recordsByID"]
[::std::mem::offset_of!(TweakDB, recordsByID) - 88usize];
["Offset of field: TweakDB::recordsByType"]
[::std::mem::offset_of!(TweakDB, recordsByType) - 136usize];
["Offset of field: TweakDB::queries"]
[::std::mem::offset_of!(TweakDB, queries) - 184usize];
["Offset of field: TweakDB::groups"]
[::std::mem::offset_of!(TweakDB, groups) - 224usize];
["Offset of field: TweakDB::defaultValues"]
[::std::mem::offset_of!(TweakDB, defaultValues) - 264usize];
["Offset of field: TweakDB::unk138"]
[::std::mem::offset_of!(TweakDB, unk138) - 312usize];
["Offset of field: TweakDB::flatDataBuffer"]
[::std::mem::offset_of!(TweakDB, flatDataBuffer) - 328usize];
["Offset of field: TweakDB::flatDataBufferCapacity"]
[::std::mem::offset_of!(TweakDB, flatDataBufferCapacity) - 336usize];
["Offset of field: TweakDB::flatDataBufferEnd"]
[::std::mem::offset_of!(TweakDB, flatDataBufferEnd) - 344usize];
["Offset of field: TweakDB::unk160"]
[::std::mem::offset_of!(TweakDB, unk160) - 352usize];
["Offset of field: TweakDB::unk164"]
[::std::mem::offset_of!(TweakDB, unk164) - 356usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?GetRecord@TweakDB@RED4ext@@QEAA?AV?$Handle@UIScriptable@RED4ext@@@2@UTweakDBID@2@@Z"]
pub fn TweakDB_GetRecord(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> root::RED4ext::Handle<root::RED4ext::IScriptable>;
}
unsafe extern "C" {
#[link_name = "\u{1}?TryGetRecord@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@AEAV?$Handle@UIScriptable@RED4ext@@@2@@Z"]
pub fn TweakDB_TryGetRecord(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aRecord: *mut root::RED4ext::Handle<root::RED4ext::IScriptable>,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetRecordsByType@TweakDB@RED4ext@@QEAA?AU?$DynArray@V?$Handle@UIScriptable@RED4ext@@@RED4ext@@@2@PEAUCBaseRTTIType@2@@Z"]
pub fn TweakDB_GetRecordsByType(
this: *mut root::RED4ext::TweakDB,
aType: *mut root::RED4ext::CBaseRTTIType,
) -> root::RED4ext::DynArray<root::RED4ext::Handle<root::RED4ext::IScriptable>>;
}
unsafe extern "C" {
#[link_name = "\u{1}?TryGetRecordsByType@TweakDB@RED4ext@@QEAA_NPEAUCBaseRTTIType@2@AEAU?$DynArray@V?$Handle@UIScriptable@RED4ext@@@RED4ext@@@2@@Z"]
pub fn TweakDB_TryGetRecordsByType(
this: *mut root::RED4ext::TweakDB,
aType: *mut root::RED4ext::CBaseRTTIType,
aRecordsArray: *mut root::RED4ext::DynArray<
root::RED4ext::Handle<root::RED4ext::IScriptable>,
>,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?AddQuery@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@AEBU?$DynArray@UTweakDBID@RED4ext@@@2@@Z"]
pub fn TweakDB_AddQuery(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aArray: *const root::RED4ext::DynArray<root::RED4ext::TweakDBID>,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ReplaceQuery@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@AEBU?$DynArray@UTweakDBID@RED4ext@@@2@@Z"]
pub fn TweakDB_ReplaceQuery(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aArray: *const root::RED4ext::DynArray<root::RED4ext::TweakDBID>,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?Query@TweakDB@RED4ext@@QEAA?AU?$DynArray@UTweakDBID@RED4ext@@@2@UTweakDBID@2@@Z"]
pub fn TweakDB_Query(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> root::RED4ext::DynArray<root::RED4ext::TweakDBID>;
}
unsafe extern "C" {
#[link_name = "\u{1}?TryQuery@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@AEAU?$DynArray@UTweakDBID@RED4ext@@@2@@Z"]
pub fn TweakDB_TryQuery(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aArray: *mut root::RED4ext::DynArray<root::RED4ext::TweakDBID>,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?HasQuery@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@@Z"]
pub fn TweakDB_HasQuery(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?AddGroupTag@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@W4GroupTag@12@@Z"]
pub fn TweakDB_AddGroupTag(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aGroup: root::RED4ext::TweakDB_GroupTag::Type,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?ReplaceGroupTag@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@W4GroupTag@12@@Z"]
pub fn TweakDB_ReplaceGroupTag(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aGroup: root::RED4ext::TweakDB_GroupTag::Type,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?HasGroupTag@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@@Z"]
pub fn TweakDB_HasGroupTag(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?UpdateRecord@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@@Z"]
pub fn TweakDB_UpdateRecord(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?UpdateRecord@TweakDB@RED4ext@@QEAA_NPEAUTweakDBRecord@data@game@2@@Z"]
pub fn TweakDB_UpdateRecord1(
this: *mut root::RED4ext::TweakDB,
aRecord: *mut root::RED4ext::gamedataTweakDBRecord,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?CreateRecord@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@PEAUCBaseRTTIType@2@@Z"]
pub fn TweakDB_CreateRecord(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aType: *mut root::RED4ext::CBaseRTTIType,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?CreateRecord@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@I@Z"]
pub fn TweakDB_CreateRecord1(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
aTweakBaseHash: u32,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?RemoveRecord@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@@Z"]
pub fn TweakDB_RemoveRecord(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?AddFlat@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@@Z"]
pub fn TweakDB_AddFlat(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?AddFlats@TweakDB@RED4ext@@QEAA_NAEBU?$SortedArray@UTweakDBID@RED4ext@@U?$less@UTweakDBID@RED4ext@@@std@@$00@2@@Z"]
pub fn TweakDB_AddFlats(
this: *mut root::RED4ext::TweakDB,
aDBIDs: *const root::__BindgenOpaqueArray<u64, 3usize>,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?RemoveFlat@TweakDB@RED4ext@@QEAA_NUTweakDBID@2@@Z"]
pub fn TweakDB_RemoveFlat(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> bool;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetFlatValue@TweakDB@RED4ext@@QEAAPEAUFlatValue@12@UTweakDBID@2@@Z"]
pub fn TweakDB_GetFlatValue(
this: *mut root::RED4ext::TweakDB,
aDBID: root::RED4ext::TweakDBID,
) -> *mut root::RED4ext::TweakDB_FlatValue;
}
unsafe extern "C" {
#[link_name = "\u{1}?CreateFlatValue@TweakDB@RED4ext@@QEAAHAEBUCStackType@2@@Z"]
pub fn TweakDB_CreateFlatValue(
this: *mut root::RED4ext::TweakDB,
aStackType: *const root::RED4ext::CStackType,
) -> i32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetDefaultFlatValue@TweakDB@RED4ext@@QEAAPEBUFlatValue@12@UCName@2@@Z"]
pub fn TweakDB_GetDefaultFlatValue(
this: *mut root::RED4ext::TweakDB,
aTypeName: root::RED4ext::CName,
) -> *const root::RED4ext::TweakDB_FlatValue;
}
unsafe extern "C" {
#[link_name = "\u{1}?Get@TweakDB@RED4ext@@SAPEAU12@XZ"]
pub fn TweakDB_Get() -> *mut root::RED4ext::TweakDB;
}
impl Default for TweakDB {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl TweakDB {
#[inline]
pub unsafe fn GetRecord(
&mut self,
aDBID: root::RED4ext::TweakDBID,
) -> root::RED4ext::Handle<root::RED4ext::IScriptable> {
TweakDB_GetRecord(self, aDBID)
}
#[inline]
pub unsafe fn TryGetRecord(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aRecord: *mut root::RED4ext::Handle<root::RED4ext::IScriptable>,
) -> bool {
TweakDB_TryGetRecord(self, aDBID, aRecord)
}
#[inline]
pub unsafe fn GetRecordsByType(
&mut self,
aType: *mut root::RED4ext::CBaseRTTIType,
) -> root::RED4ext::DynArray<root::RED4ext::Handle<root::RED4ext::IScriptable>>
{
TweakDB_GetRecordsByType(self, aType)
}
#[inline]
pub unsafe fn TryGetRecordsByType(
&mut self,
aType: *mut root::RED4ext::CBaseRTTIType,
aRecordsArray: *mut root::RED4ext::DynArray<
root::RED4ext::Handle<root::RED4ext::IScriptable>,
>,
) -> bool {
TweakDB_TryGetRecordsByType(self, aType, aRecordsArray)
}
#[inline]
pub unsafe fn AddQuery(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aArray: *const root::RED4ext::DynArray<root::RED4ext::TweakDBID>,
) -> bool {
TweakDB_AddQuery(self, aDBID, aArray)
}
#[inline]
pub unsafe fn ReplaceQuery(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aArray: *const root::RED4ext::DynArray<root::RED4ext::TweakDBID>,
) -> bool {
TweakDB_ReplaceQuery(self, aDBID, aArray)
}
#[inline]
pub unsafe fn Query(
&mut self,
aDBID: root::RED4ext::TweakDBID,
) -> root::RED4ext::DynArray<root::RED4ext::TweakDBID> {
TweakDB_Query(self, aDBID)
}
#[inline]
pub unsafe fn TryQuery(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aArray: *mut root::RED4ext::DynArray<root::RED4ext::TweakDBID>,
) -> bool {
TweakDB_TryQuery(self, aDBID, aArray)
}
#[inline]
pub unsafe fn HasQuery(&mut self, aDBID: root::RED4ext::TweakDBID) -> bool {
TweakDB_HasQuery(self, aDBID)
}
#[inline]
pub unsafe fn AddGroupTag(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aGroup: root::RED4ext::TweakDB_GroupTag::Type,
) -> bool {
TweakDB_AddGroupTag(self, aDBID, aGroup)
}
#[inline]
pub unsafe fn ReplaceGroupTag(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aGroup: root::RED4ext::TweakDB_GroupTag::Type,
) -> bool {
TweakDB_ReplaceGroupTag(self, aDBID, aGroup)
}
#[inline]
pub unsafe fn HasGroupTag(&mut self, aDBID: root::RED4ext::TweakDBID) -> bool {
TweakDB_HasGroupTag(self, aDBID)
}
#[inline]
pub unsafe fn UpdateRecord(&mut self, aDBID: root::RED4ext::TweakDBID) -> bool {
TweakDB_UpdateRecord(self, aDBID)
}
#[inline]
pub unsafe fn UpdateRecord1(
&mut self,
aRecord: *mut root::RED4ext::gamedataTweakDBRecord,
) -> bool {
TweakDB_UpdateRecord1(self, aRecord)
}
#[inline]
pub unsafe fn CreateRecord(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aType: *mut root::RED4ext::CBaseRTTIType,
) -> bool {
TweakDB_CreateRecord(self, aDBID, aType)
}
#[inline]
pub unsafe fn CreateRecord1(
&mut self,
aDBID: root::RED4ext::TweakDBID,
aTweakBaseHash: u32,
) -> bool {
TweakDB_CreateRecord1(self, aDBID, aTweakBaseHash)
}
#[inline]
pub unsafe fn RemoveRecord(&mut self, aDBID: root::RED4ext::TweakDBID) -> bool {
TweakDB_RemoveRecord(self, aDBID)
}
#[inline]
pub unsafe fn AddFlat(&mut self, aDBID: root::RED4ext::TweakDBID) -> bool {
TweakDB_AddFlat(self, aDBID)
}
#[inline]
pub unsafe fn AddFlats(
&mut self,
aDBIDs: *const root::__BindgenOpaqueArray<u64, 3usize>,
) -> bool {
TweakDB_AddFlats(self, aDBIDs)
}
#[inline]
pub unsafe fn RemoveFlat(&mut self, aDBID: root::RED4ext::TweakDBID) -> bool {
TweakDB_RemoveFlat(self, aDBID)
}
#[inline]
pub unsafe fn GetFlatValue(
&mut self,
aDBID: root::RED4ext::TweakDBID,
) -> *mut root::RED4ext::TweakDB_FlatValue {
TweakDB_GetFlatValue(self, aDBID)
}
#[inline]
pub unsafe fn CreateFlatValue(
&mut self,
aStackType: *const root::RED4ext::CStackType,
) -> i32 {
TweakDB_CreateFlatValue(self, aStackType)
}
#[inline]
pub unsafe fn GetDefaultFlatValue(
&mut self,
aTypeName: root::RED4ext::CName,
) -> *const root::RED4ext::TweakDB_FlatValue {
TweakDB_GetDefaultFlatValue(self, aTypeName)
}
#[inline]
pub unsafe fn Get() -> *mut root::RED4ext::TweakDB {
TweakDB_Get()
}
}
pub mod EMainReason {
pub type Type = u8;
pub const Load: Type = 0;
pub const Unload: Type = 1;
}
pub mod ent {
#[allow(unused_imports)]
use self::super::super::super::root;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct EntityID {
pub hash: u64,
}
pub const EntityID_NAME: &[u8; 12] = b"entEntityID\0";
pub const EntityID_ALIAS: &[u8; 9] = b"EntityID\0";
pub const EntityID_DynamicUpperBound: u64 = 16777215;
pub const EntityID_PersistableLowerBound: u64 = 9000000;
pub const EntityID_PersistableUpperBound: u64 = 10000000;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of EntityID"][::std::mem::size_of::<EntityID>() - 8usize];
["Alignment of EntityID"][::std::mem::align_of::<EntityID>() - 8usize];
["Offset of field: EntityID::hash"]
[::std::mem::offset_of!(EntityID, hash) - 0usize];
};
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct GameTime {
pub seconds: u32,
}
pub const GameTime_OneSecond: u32 = 1;
pub const GameTime_OneMinute: u32 = 60;
pub const GameTime_OneHour: u32 = 3600;
pub const GameTime_OneDay: u32 = 86400;
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of GameTime"][::std::mem::size_of::<GameTime>() - 4usize];
["Alignment of GameTime"][::std::mem::align_of::<GameTime>() - 4usize];
["Offset of field: GameTime::seconds"]
[::std::mem::offset_of!(GameTime, seconds) - 0usize];
};
unsafe extern "C" {
#[link_name = "\u{1}?ToString@GameTime@RED4ext@@QEBA?BV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ"]
pub fn GameTime_ToString(this: *const root::RED4ext::GameTime) -> root::std::string;
}
unsafe extern "C" {
#[link_name = "\u{1}?ToSeconds@GameTime@RED4ext@@QEBA?BIXZ"]
pub fn GameTime_ToSeconds(this: *const root::RED4ext::GameTime) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetDay@GameTime@RED4ext@@QEBA?BIXZ"]
pub fn GameTime_GetDay(this: *const root::RED4ext::GameTime) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetHour@GameTime@RED4ext@@QEBA?BIXZ"]
pub fn GameTime_GetHour(this: *const root::RED4ext::GameTime) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetMinute@GameTime@RED4ext@@QEBA?BIXZ"]
pub fn GameTime_GetMinute(this: *const root::RED4ext::GameTime) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?GetSecond@GameTime@RED4ext@@QEBA?BIXZ"]
pub fn GameTime_GetSecond(this: *const root::RED4ext::GameTime) -> u32;
}
unsafe extern "C" {
#[link_name = "\u{1}?SetDay@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_SetDay(this: *mut root::RED4ext::GameTime, aDay: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}?SetHour@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_SetHour(this: *mut root::RED4ext::GameTime, aHour: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}?SetMinute@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_SetMinute(this: *mut root::RED4ext::GameTime, aMinute: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}?SetSecond@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_SetSecond(this: *mut root::RED4ext::GameTime, aSecond: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}?SetTime@GameTime@RED4ext@@QEAAXIIII@Z"]
pub fn GameTime_SetTime(
this: *mut root::RED4ext::GameTime,
aDay: u32,
aHour: u32,
aMinute: u32,
aSecond: u32,
);
}
unsafe extern "C" {
#[link_name = "\u{1}?AddDays@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_AddDays(this: *mut root::RED4ext::GameTime, aDays: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}?AddHours@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_AddHours(this: *mut root::RED4ext::GameTime, aHours: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}?AddMinutes@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_AddMinutes(this: *mut root::RED4ext::GameTime, aMinutes: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}?AddSeconds@GameTime@RED4ext@@QEAAXI@Z"]
pub fn GameTime_AddSeconds(this: *mut root::RED4ext::GameTime, aSeconds: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}??0GameTime@RED4ext@@QEAA@I@Z"]
pub fn GameTime_GameTime(this: *mut root::RED4ext::GameTime, aSeconds: u32);
}
unsafe extern "C" {
#[link_name = "\u{1}??0GameTime@RED4ext@@QEAA@III@Z"]
pub fn GameTime_GameTime1(
this: *mut root::RED4ext::GameTime,
aHour: u32,
aMinute: u32,
aSecond: u32,
);
}
unsafe extern "C" {
#[link_name = "\u{1}??0GameTime@RED4ext@@QEAA@IIII@Z"]
pub fn GameTime_GameTime2(
this: *mut root::RED4ext::GameTime,
aDay: u32,
aHour: u32,
aMinute: u32,
aSecond: u32,
);
}
impl GameTime {
#[inline]
pub unsafe fn ToString(&self) -> root::std::string {
GameTime_ToString(self)
}
#[inline]
pub unsafe fn ToSeconds(&self) -> u32 {
GameTime_ToSeconds(self)
}
#[inline]
pub unsafe fn GetDay(&self) -> u32 {
GameTime_GetDay(self)
}
#[inline]
pub unsafe fn GetHour(&self) -> u32 {
GameTime_GetHour(self)
}
#[inline]
pub unsafe fn GetMinute(&self) -> u32 {
GameTime_GetMinute(self)
}
#[inline]
pub unsafe fn GetSecond(&self) -> u32 {
GameTime_GetSecond(self)
}
#[inline]
pub unsafe fn SetDay(&mut self, aDay: u32) {
GameTime_SetDay(self, aDay)
}
#[inline]
pub unsafe fn SetHour(&mut self, aHour: u32) {
GameTime_SetHour(self, aHour)
}
#[inline]
pub unsafe fn SetMinute(&mut self, aMinute: u32) {
GameTime_SetMinute(self, aMinute)
}
#[inline]
pub unsafe fn SetSecond(&mut self, aSecond: u32) {
GameTime_SetSecond(self, aSecond)
}
#[inline]
pub unsafe fn SetTime(&mut self, aDay: u32, aHour: u32, aMinute: u32, aSecond: u32) {
GameTime_SetTime(self, aDay, aHour, aMinute, aSecond)
}
#[inline]
pub unsafe fn AddDays(&mut self, aDays: u32) {
GameTime_AddDays(self, aDays)
}
#[inline]
pub unsafe fn AddHours(&mut self, aHours: u32) {
GameTime_AddHours(self, aHours)
}
#[inline]
pub unsafe fn AddMinutes(&mut self, aMinutes: u32) {
GameTime_AddMinutes(self, aMinutes)
}
#[inline]
pub unsafe fn AddSeconds(&mut self, aSeconds: u32) {
GameTime_AddSeconds(self, aSeconds)
}
#[inline]
pub unsafe fn new(aSeconds: u32) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
GameTime_GameTime(__bindgen_tmp.as_mut_ptr(), aSeconds);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(aHour: u32, aMinute: u32, aSecond: u32) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
GameTime_GameTime1(__bindgen_tmp.as_mut_ptr(), aHour, aMinute, aSecond);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new2(aDay: u32, aHour: u32, aMinute: u32, aSecond: u32) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
GameTime_GameTime2(__bindgen_tmp.as_mut_ptr(), aDay, aHour, aMinute, aSecond);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ScriptGameInstance {
pub instance: *mut root::RED4ext::GameInstance,
pub unk8: i8,
pub unk10: i64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ScriptGameInstance"][::std::mem::size_of::<ScriptGameInstance>() - 24usize];
["Alignment of ScriptGameInstance"]
[::std::mem::align_of::<ScriptGameInstance>() - 8usize];
["Offset of field: ScriptGameInstance::instance"]
[::std::mem::offset_of!(ScriptGameInstance, instance) - 0usize];
["Offset of field: ScriptGameInstance::unk8"]
[::std::mem::offset_of!(ScriptGameInstance, unk8) - 8usize];
["Offset of field: ScriptGameInstance::unk10"]
[::std::mem::offset_of!(ScriptGameInstance, unk10) - 16usize];
};
unsafe extern "C" {
#[link_name = "\u{1}??0ScriptGameInstance@RED4ext@@QEAA@PEAUGameInstance@1@@Z"]
pub fn ScriptGameInstance_ScriptGameInstance(
this: *mut root::RED4ext::ScriptGameInstance,
aInstance: *mut root::RED4ext::GameInstance,
);
}
impl Default for ScriptGameInstance {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl ScriptGameInstance {
#[inline]
pub unsafe fn new(aInstance: *mut root::RED4ext::GameInstance) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
ScriptGameInstance_ScriptGameInstance(__bindgen_tmp.as_mut_ptr(), aInstance);
__bindgen_tmp.assume_init()
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct EngineTime {
pub ticks: u64,
}
pub const EngineTime_NAME: &[u8; 11] = b"EngineTime\0";
unsafe extern "C" {
#[link_name = "\u{1}?ALIAS@EngineTime@RED4ext@@2QEBDEB"]
pub static EngineTime_ALIAS: *const ::std::os::raw::c_char;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of EngineTime"][::std::mem::size_of::<EngineTime>() - 8usize];
["Alignment of EngineTime"][::std::mem::align_of::<EngineTime>() - 8usize];
["Offset of field: EngineTime::ticks"]
[::std::mem::offset_of!(EngineTime, ticks) - 0usize];
};
pub type gameIScriptableSystem = root::RED4ext::game::IScriptableSystem;
pub type IScriptableSystem = root::RED4ext::game::IScriptableSystem;
pub type gameScriptableSystem = root::RED4ext::game::ScriptableSystem;
pub type ScriptableSystem = root::RED4ext::game::ScriptableSystem;
pub mod red {
#[allow(unused_imports)]
use self::super::super::super::root;
#[repr(C)]
#[derive(Debug)]
pub struct ResourceReferenceScriptToken {
pub resource: root::RED4ext::ResourceAsyncReference,
}
pub const ResourceReferenceScriptToken_NAME: &[u8; 32] =
b"redResourceReferenceScriptToken\0";
pub const ResourceReferenceScriptToken_ALIAS: &[u8; 7] = b"ResRef\0";
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of ResourceReferenceScriptToken"]
[::std::mem::size_of::<ResourceReferenceScriptToken>() - 8usize];
["Alignment of ResourceReferenceScriptToken"]
[::std::mem::align_of::<ResourceReferenceScriptToken>() - 8usize];
["Offset of field: ResourceReferenceScriptToken::resource"]
[::std::mem::offset_of!(ResourceReferenceScriptToken, resource) - 0usize];
};
impl Default for ResourceReferenceScriptToken {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
}
pub type redResourceReferenceScriptToken = root::RED4ext::red::ResourceReferenceScriptToken;
pub type ResRef = root::RED4ext::red::ResourceReferenceScriptToken;
}
pub type DWORD = ::std::os::raw::c_ulong;
pub type WORD = ::std::os::raw::c_ushort;
pub type ULONG_PTR = ::std::os::raw::c_ulonglong;
pub type LONG = ::std::os::raw::c_long;
pub type HANDLE = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LIST_ENTRY {
pub Flink: *mut root::_LIST_ENTRY,
pub Blink: *mut root::_LIST_ENTRY,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _LIST_ENTRY"][::std::mem::size_of::<_LIST_ENTRY>() - 16usize];
["Alignment of _LIST_ENTRY"][::std::mem::align_of::<_LIST_ENTRY>() - 8usize];
["Offset of field: _LIST_ENTRY::Flink"]
[::std::mem::offset_of!(_LIST_ENTRY, Flink) - 0usize];
["Offset of field: _LIST_ENTRY::Blink"]
[::std::mem::offset_of!(_LIST_ENTRY, Blink) - 8usize];
};
impl Default for _LIST_ENTRY {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type LIST_ENTRY = root::_LIST_ENTRY;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _RTL_CRITICAL_SECTION_DEBUG {
pub Type: root::WORD,
pub CreatorBackTraceIndex: root::WORD,
pub CriticalSection: *mut root::_RTL_CRITICAL_SECTION,
pub ProcessLocksList: root::LIST_ENTRY,
pub EntryCount: root::DWORD,
pub ContentionCount: root::DWORD,
pub Flags: root::DWORD,
pub CreatorBackTraceIndexHigh: root::WORD,
pub Identifier: root::WORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _RTL_CRITICAL_SECTION_DEBUG"]
[::std::mem::size_of::<_RTL_CRITICAL_SECTION_DEBUG>() - 48usize];
["Alignment of _RTL_CRITICAL_SECTION_DEBUG"]
[::std::mem::align_of::<_RTL_CRITICAL_SECTION_DEBUG>() - 8usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Type"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Type) - 0usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CreatorBackTraceIndex"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndex) - 2usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CriticalSection"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CriticalSection) - 8usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::ProcessLocksList"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, ProcessLocksList) - 16usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::EntryCount"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, EntryCount) - 32usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::ContentionCount"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, ContentionCount) - 36usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Flags"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Flags) - 40usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CreatorBackTraceIndexHigh"][::std::mem::offset_of!(
_RTL_CRITICAL_SECTION_DEBUG,
CreatorBackTraceIndexHigh
) - 44usize];
["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Identifier"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Identifier) - 46usize];
};
impl Default for _RTL_CRITICAL_SECTION_DEBUG {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type PRTL_CRITICAL_SECTION_DEBUG = *mut root::_RTL_CRITICAL_SECTION_DEBUG;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _RTL_CRITICAL_SECTION {
pub DebugInfo: root::PRTL_CRITICAL_SECTION_DEBUG,
pub LockCount: root::LONG,
pub RecursionCount: root::LONG,
pub OwningThread: root::HANDLE,
pub LockSemaphore: root::HANDLE,
pub SpinCount: root::ULONG_PTR,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _RTL_CRITICAL_SECTION"][::std::mem::size_of::<_RTL_CRITICAL_SECTION>() - 40usize];
["Alignment of _RTL_CRITICAL_SECTION"]
[::std::mem::align_of::<_RTL_CRITICAL_SECTION>() - 8usize];
["Offset of field: _RTL_CRITICAL_SECTION::DebugInfo"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION, DebugInfo) - 0usize];
["Offset of field: _RTL_CRITICAL_SECTION::LockCount"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION, LockCount) - 8usize];
["Offset of field: _RTL_CRITICAL_SECTION::RecursionCount"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION, RecursionCount) - 12usize];
["Offset of field: _RTL_CRITICAL_SECTION::OwningThread"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION, OwningThread) - 16usize];
["Offset of field: _RTL_CRITICAL_SECTION::LockSemaphore"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION, LockSemaphore) - 24usize];
["Offset of field: _RTL_CRITICAL_SECTION::SpinCount"]
[::std::mem::offset_of!(_RTL_CRITICAL_SECTION, SpinCount) - 32usize];
};
impl Default for _RTL_CRITICAL_SECTION {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type RTL_CRITICAL_SECTION = root::_RTL_CRITICAL_SECTION;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct HINSTANCE__ {
pub unused: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of HINSTANCE__"][::std::mem::size_of::<HINSTANCE__>() - 4usize];
["Alignment of HINSTANCE__"][::std::mem::align_of::<HINSTANCE__>() - 4usize];
["Offset of field: HINSTANCE__::unused"]
[::std::mem::offset_of!(HINSTANCE__, unused) - 0usize];
};
pub type HINSTANCE = *mut root::HINSTANCE__;
pub type HMODULE = root::HINSTANCE;
pub type CRITICAL_SECTION = root::RTL_CRITICAL_SECTION;
pub mod versioning {
#[allow(unused_imports)]
use self::super::super::root;
pub const RUNTIME_INDEPENDENT: u16 = 65535;
pub const SDK_MAJOR: u8 = 0;
pub const SDK_MINOR: u16 = 5;
pub const SDK_PATCH: u32 = 0;
pub const API_VERSION_LATEST: u32 = 0;
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: fpos_open0__Mbstatet_close0"]
[::std::mem::size_of::<root::std::fpos<root::_Mbstatet>>() - 24usize];
["Align of template specialization: fpos_open0__Mbstatet_close0"]
[::std::mem::align_of::<root::std::fpos<root::_Mbstatet>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: basic_string_view_open0_wchar_t_char_traits_open1_wchar_t_close1_close0"] [:: std :: mem :: size_of :: < root :: std :: basic_string_view < u16 > > () - 16usize] ;
["Align of template specialization: basic_string_view_open0_wchar_t_char_traits_open1_wchar_t_close1_close0"] [:: std :: mem :: align_of :: < root :: std :: basic_string_view < u16 > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: char_traits_open0_wchar_t_close0"]
[::std::mem::size_of::<root::std::char_traits>() - 1usize];
["Align of template specialization: char_traits_open0_wchar_t_close0"]
[::std::mem::align_of::<root::std::char_traits>() - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: TPoolInfo_open0_PoolEngine_close0"]
[::std::mem::size_of::<root::RED4ext::Memory::TPoolInfo>() - 80usize];
["Align of template specialization: TPoolInfo_open0_PoolEngine_close0"]
[::std::mem::align_of::<root::RED4ext::Memory::TPoolInfo>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: TPoolInfo_open0_PoolRefCount_close0"]
[::std::mem::size_of::<root::RED4ext::Memory::TPoolInfo>() - 80usize];
["Align of template specialization: TPoolInfo_open0_PoolRefCount_close0"]
[::std::mem::align_of::<root::RED4ext::Memory::TPoolInfo>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: TPoolInfo_open0_PoolJobs2Data_close0"]
[::std::mem::size_of::<root::RED4ext::Memory::TPoolInfo>() - 80usize];
["Align of template specialization: TPoolInfo_open0_PoolJobs2Data_close0"]
[::std::mem::align_of::<root::RED4ext::Memory::TPoolInfo>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Allocator_open0_PoolEngine_close0"]
[::std::mem::size_of::<root::RED4ext::Memory::Allocator>() - 8usize];
["Align of template specialization: Allocator_open0_PoolEngine_close0"]
[::std::mem::align_of::<root::RED4ext::Memory::Allocator>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Allocator_open0_PoolRefCount_close0"]
[::std::mem::size_of::<root::RED4ext::Memory::Allocator>() - 8usize];
["Align of template specialization: Allocator_open0_PoolRefCount_close0"]
[::std::mem::align_of::<root::RED4ext::Memory::Allocator>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Allocator_open0_PoolJobs2Data_close0"]
[::std::mem::size_of::<root::RED4ext::Memory::Allocator>() - 8usize];
["Align of template specialization: Allocator_open0_PoolJobs2Data_close0"]
[::std::mem::align_of::<root::RED4ext::Memory::Allocator>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_EGameStateType_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::EGameStateType::Type>>()
- 16usize];
["Align of template specialization: DynArray_open0_EGameStateType_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::EGameStateType::Type>>(
) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_IGameState_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<*mut root::RED4ext::IGameState>>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_IGameState_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::IGameState>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_ptr_CBaseRTTIType_Handle_open1_IScriptable_close1__bindgen_ty_id_504602_open1_ptr_CBaseRTTIType_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < * mut root :: RED4ext :: CBaseRTTIType , root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 48usize] ;
["Align of template specialization: HashMap_open0_ptr_CBaseRTTIType_Handle_open1_IScriptable_close1__bindgen_ty_id_504602_open1_ptr_CBaseRTTIType_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < * mut root :: RED4ext :: CBaseRTTIType , root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_ptr_CBaseRTTIType_ptr_CBaseRTTIType__bindgen_ty_id_504619_open1_ptr_CBaseRTTIType_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < * mut root :: RED4ext :: CBaseRTTIType , * mut root :: RED4ext :: CBaseRTTIType > > () - 48usize] ;
["Align of template specialization: HashMap_open0_ptr_CBaseRTTIType_ptr_CBaseRTTIType__bindgen_ty_id_504619_open1_ptr_CBaseRTTIType_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < * mut root :: RED4ext :: CBaseRTTIType , * mut root :: RED4ext :: CBaseRTTIType > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_CString_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 16usize];
["Align of template specialization: DynArray_open0_CString_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: WeakHandle_open0_ISerializable_close0"]
[::std::mem::size_of::<root::RED4ext::WeakHandle<root::RED4ext::ISerializable>>()
- 16usize];
["Align of template specialization: WeakHandle_open0_ISerializable_close0"]
[::std::mem::align_of::<root::RED4ext::WeakHandle<root::RED4ext::ISerializable>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: WeakHandle_open0_ISerializable_close0"]
[::std::mem::size_of::<root::RED4ext::WeakHandle<root::RED4ext::ISerializable>>()
- 16usize];
["Align of template specialization: WeakHandle_open0_ISerializable_close0"]
[::std::mem::align_of::<root::RED4ext::WeakHandle<root::RED4ext::ISerializable>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: WeakHandle_open0_IScriptable_close0"][::std::mem::size_of::<
root::RED4ext::WeakHandle<root::RED4ext::IScriptable>,
>()
- 16usize];
["Align of template specialization: WeakHandle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::WeakHandle<root::RED4ext::IScriptable>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: WeakHandle_open0_IScriptable_close0"][::std::mem::size_of::<
root::RED4ext::WeakHandle<root::RED4ext::IScriptable>,
>()
- 16usize];
["Align of template specialization: WeakHandle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::WeakHandle<root::RED4ext::IScriptable>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Map_open0_ptr_void_ptr_void_less_open1_ptr_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: Map < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 40usize] ;
["Align of template specialization: Map_open0_ptr_void_ptr_void_less_open1_ptr_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: Map < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CClassFunction_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<*mut root::RED4ext::CClassFunction>>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CClassFunction_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CClassFunction>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CClassStaticFunction_close0"]
[::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CClassStaticFunction>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_CClassStaticFunction_close0"]
[::std::mem::align_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CClassStaticFunction>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_ptr_CClassFunction__bindgen_ty_id_505016_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CClassFunction > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_ptr_CClassFunction__bindgen_ty_id_505016_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CClassFunction > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_ptr_void_ptr_void_HashMapHash_open1_ptr_void_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 48usize] ;
["Align of template specialization: HashMap_open0_ptr_void_ptr_void_HashMapHash_open1_ptr_void_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_ptr_CProperty__bindgen_ty_id_505041_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CProperty > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_ptr_CProperty__bindgen_ty_id_505041_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CProperty > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Map_open0_CName_ptr_Variant_less_open1_CName_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: Map < root :: RED4ext :: CName , * mut root :: RED4ext :: Variant > > () - 40usize] ;
["Align of template specialization: Map_open0_CName_ptr_Variant_less_open1_CName_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: Map < root :: RED4ext :: CName , * mut root :: RED4ext :: Variant > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_ptr_void_ptr_void_HashMapHash_open1_ptr_void_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 48usize] ;
["Align of template specialization: HashMap_open0_ptr_void_ptr_void_HashMapHash_open1_ptr_void_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_CClass_Listener_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::CClass_Listener>>()
- 16usize];
["Align of template specialization: DynArray_open0_CClass_Listener_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::CClass_Listener>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_CName_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::CName>>() - 16usize];
["Align of template specialization: DynArray_open0_CName_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::CName>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_int64_t_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<i64>>() - 16usize];
["Align of template specialization: DynArray_open0_int64_t_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<i64>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_CName_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::CName>>() - 16usize];
["Align of template specialization: DynArray_open0_CName_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::CName>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_int64_t_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<i64>>() - 16usize];
["Align of template specialization: DynArray_open0_int64_t_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<i64>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: JobInstance_HandleFunc_open0_void_close0"]
[::std::mem::size_of::<root::RED4ext::JobInstance_HandleFunc<::std::os::raw::c_void>>(
) - 8usize];
["Align of template specialization: JobInstance_HandleFunc_open0_void_close0"]
[::std::mem::align_of::<root::RED4ext::JobInstance_HandleFunc<::std::os::raw::c_void>>(
) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: JobInstance_TargetPtr_open0_void_close0"]
[::std::mem::size_of::<root::RED4ext::JobInstance_TargetPtr<::std::os::raw::c_void>>()
- 8usize];
["Align of template specialization: JobInstance_TargetPtr_open0_void_close0"]
[::std::mem::align_of::<root::RED4ext::JobInstance_TargetPtr<::std::os::raw::c_void>>(
) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: JobInstance_HandleFunc_open0_void_close0"]
[::std::mem::size_of::<root::RED4ext::JobInstance_HandleFunc<::std::os::raw::c_void>>(
) - 8usize];
["Align of template specialization: JobInstance_HandleFunc_open0_void_close0"]
[::std::mem::align_of::<root::RED4ext::JobInstance_HandleFunc<::std::os::raw::c_void>>(
) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: JobInstance_TargetPtr_open0_void_close0"]
[::std::mem::size_of::<root::RED4ext::JobInstance_TargetPtr<::std::os::raw::c_void>>()
- 8usize];
["Align of template specialization: JobInstance_TargetPtr_open0_void_close0"]
[::std::mem::align_of::<root::RED4ext::JobInstance_TargetPtr<::std::os::raw::c_void>>(
) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: SharedPtr_open0_DeferredDataBufferToken_close0"]
[::std::mem::size_of::<root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferToken>>(
) - 16usize];
["Align of template specialization: SharedPtr_open0_DeferredDataBufferToken_close0"]
[::std::mem::align_of::<
root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferToken>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: SharedPtr_open0_DeferredDataBufferCopyToken_close0"]
[::std::mem::size_of::<
root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferCopyToken>,
>() - 16usize];
["Align of template specialization: SharedPtr_open0_DeferredDataBufferCopyToken_close0"]
[::std::mem::align_of::<
root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferCopyToken>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: SharedPtr_open0_RawBuffer_close0"]
[::std::mem::size_of::<root::RED4ext::SharedPtr<root::RED4ext::RawBuffer>>() - 16usize];
["Align of template specialization: SharedPtr_open0_RawBuffer_close0"]
[::std::mem::align_of::<root::RED4ext::SharedPtr<root::RED4ext::RawBuffer>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: SharedPtr_open0_DeferredDataBufferCopyToken_close0"]
[::std::mem::size_of::<
root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferCopyToken>,
>() - 16usize];
["Align of template specialization: SharedPtr_open0_DeferredDataBufferCopyToken_close0"]
[::std::mem::align_of::<
root::RED4ext::SharedPtr<root::RED4ext::DeferredDataBufferCopyToken>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: WeakPtr_open0_DeferredDataBufferCopyToken_close0"]
[::std::mem::size_of::<
root::RED4ext::WeakPtr<root::RED4ext::DeferredDataBufferCopyToken>,
>() - 16usize];
["Align of template specialization: WeakPtr_open0_DeferredDataBufferCopyToken_close0"]
[::std::mem::align_of::<
root::RED4ext::WeakPtr<root::RED4ext::DeferredDataBufferCopyToken>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: SharedPtr_open0_RawBuffer_close0"]
[::std::mem::size_of::<root::RED4ext::SharedPtr<root::RED4ext::RawBuffer>>() - 16usize];
["Align of template specialization: SharedPtr_open0_RawBuffer_close0"]
[::std::mem::align_of::<root::RED4ext::SharedPtr<root::RED4ext::RawBuffer>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_SharedPtr_open1_ResourceToken_open2_CResource_close2_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_SharedPtr_open1_ResourceToken_open2_CResource_close2_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: SharedPtr_open0_ResourceToken_open1_CResource_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > () - 16usize] ;
["Align of template specialization: SharedPtr_open0_ResourceToken_open1_CResource_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: ResourceToken_open0_CResource_close0"]
[::std::mem::size_of::<root::RED4ext::ResourceToken<root::RED4ext::CResource>>()
- 96usize];
["Align of template specialization: ResourceToken_open0_CResource_close0"]
[::std::mem::align_of::<root::RED4ext::ResourceToken<root::RED4ext::CResource>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_ResourcePath_WeakPtr_open1_ResourceToken_open2_CResource_close2_close1_HashMapHash_open1_ResourcePath_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: ResourcePath , root :: RED4ext :: WeakPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > > () - 48usize] ;
["Align of template specialization: HashMap_open0_ResourcePath_WeakPtr_open1_ResourceToken_open2_CResource_close2_close1_HashMapHash_open1_ResourcePath_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: ResourcePath , root :: RED4ext :: WeakPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: WeakPtr_open0_ResourceToken_open1_CResource_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: WeakPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > () - 16usize] ;
["Align of template specialization: WeakPtr_open0_ResourceToken_open1_CResource_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: WeakPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: ResourceToken_open0_CResource_close0"]
[::std::mem::size_of::<root::RED4ext::ResourceToken<root::RED4ext::CResource>>()
- 96usize];
["Align of template specialization: ResourceToken_open0_CResource_close0"]
[::std::mem::align_of::<root::RED4ext::ResourceToken<root::RED4ext::CResource>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_SharedPtr_open1_ResourceToken_open2_CResource_close2_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_SharedPtr_open1_ResourceToken_open2_CResource_close2_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: SharedPtr_open0_ResourceToken_open1_CResource_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > () - 16usize] ;
["Align of template specialization: SharedPtr_open0_ResourceToken_open1_CResource_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: SharedPtr < root :: RED4ext :: ResourceToken < root :: RED4ext :: CResource > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: ResourceToken_open0_CResource_close0"]
[::std::mem::size_of::<root::RED4ext::ResourceToken<root::RED4ext::CResource>>()
- 96usize];
["Align of template specialization: ResourceToken_open0_CResource_close0"]
[::std::mem::align_of::<root::RED4ext::ResourceToken<root::RED4ext::CResource>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_CString_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 16usize];
["Align of template specialization: DynArray_open0_CString_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_ptr_CBaseRTTIType__bindgen_ty_id_505752_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CBaseRTTIType > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_ptr_CBaseRTTIType__bindgen_ty_id_505752_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CBaseRTTIType > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_uint64_t_ptr_CBaseRTTIType_HashMapHash_open1_unsigned_long_long_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < u64 , * mut root :: RED4ext :: CBaseRTTIType > > () - 48usize] ;
["Align of template specialization: HashMap_open0_uint64_t_ptr_CBaseRTTIType_HashMapHash_open1_unsigned_long_long_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < u64 , * mut root :: RED4ext :: CBaseRTTIType > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_uint32_t__bindgen_ty_id_505772_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , u32 > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_uint32_t__bindgen_ty_id_505772_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , u32 > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_ptr_CGlobalFunction__bindgen_ty_id_505782_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CGlobalFunction > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_ptr_CGlobalFunction__bindgen_ty_id_505782_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: CGlobalFunction > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_uint64_t_ptr_CGlobalFunction_HashMapHash_open1_unsigned_long_long_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < u64 , * mut root :: RED4ext :: CGlobalFunction > > () - 48usize] ;
["Align of template specialization: HashMap_open0_uint64_t_ptr_CGlobalFunction_HashMapHash_open1_unsigned_long_long_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < u64 , * mut root :: RED4ext :: CGlobalFunction > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_ptr_void_ptr_void_HashMapHash_open1_ptr_void_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 48usize] ;
["Align of template specialization: HashMap_open0_ptr_void_ptr_void_HashMapHash_open1_ptr_void_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < * mut :: std :: os :: raw :: c_void , * mut :: std :: os :: raw :: c_void > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_CName__bindgen_ty_id_505827_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , root :: RED4ext :: CName > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_CName__bindgen_ty_id_505827_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , root :: RED4ext :: CName > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_CName__bindgen_ty_id_505836_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , root :: RED4ext :: CName > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_CName__bindgen_ty_id_505836_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , root :: RED4ext :: CName > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_CString_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 16usize];
["Align of template specialization: DynArray_open0_CString_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 16usize];
["Align of template specialization: DynArray_open0_ptr_void_close0"][::std::mem::align_of::<
root::RED4ext::DynArray<*mut ::std::os::raw::c_void>,
>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_uint64_t_ptr_void_HashMapHash_open1_unsigned_long_long_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < u64 , * mut :: std :: os :: raw :: c_void > > () - 48usize] ;
["Align of template specialization: HashMap_open0_uint64_t_ptr_void_HashMapHash_open1_unsigned_long_long_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < u64 , * mut :: std :: os :: raw :: c_void > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: allocator_open0_CStackType_close0"]
[::std::mem::size_of::<root::std::allocator>() - 1usize];
["Align of template specialization: allocator_open0_CStackType_close0"]
[::std::mem::align_of::<root::std::allocator>() - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_ptr_CProperty_close0"][::std::mem::size_of::<
root::RED4ext::DynArray<*mut root::RED4ext::CProperty>,
>()
- 16usize];
["Align of template specialization: DynArray_open0_ptr_CProperty_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<*mut root::RED4ext::CProperty>>()
- 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::std::less>() - 1usize];
["Align of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::std::less>() - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_TweakDBID_Handle_open1_IScriptable_close1__bindgen_ty_id_506446_open1_TweakDBID_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: TweakDBID , root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 48usize] ;
["Align of template specialization: HashMap_open0_TweakDBID_Handle_open1_IScriptable_close1__bindgen_ty_id_506446_open1_TweakDBID_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: TweakDBID , root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_ptr_CBaseRTTIType_DynArray_open1_Handle_open2_IScriptable_close2_close1__bindgen_ty_id_506461_open1_ptr_CBaseRTTIType_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < * mut root :: RED4ext :: CBaseRTTIType , root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > > () - 48usize] ;
["Align of template specialization: HashMap_open0_ptr_CBaseRTTIType_DynArray_open1_Handle_open2_IScriptable_close2_close1__bindgen_ty_id_506461_open1_ptr_CBaseRTTIType_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < * mut root :: RED4ext :: CBaseRTTIType , root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Map_open0_TweakDBID_DynArray_open1_TweakDBID_close1_less_open1_TweakDBID_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: Map < root :: RED4ext :: TweakDBID , root :: RED4ext :: DynArray < root :: RED4ext :: TweakDBID > > > () - 40usize] ;
["Align of template specialization: Map_open0_TweakDBID_DynArray_open1_TweakDBID_close1_less_open1_TweakDBID_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: Map < root :: RED4ext :: TweakDBID , root :: RED4ext :: DynArray < root :: RED4ext :: TweakDBID > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::std::less>() - 1usize];
["Align of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::std::less>() - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Map_open0_TweakDBID_TweakDB_GroupTag_less_open1_TweakDBID_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: Map < root :: RED4ext :: TweakDBID , root :: RED4ext :: TweakDB_GroupTag :: Type > > () - 40usize] ;
["Align of template specialization: Map_open0_TweakDBID_TweakDB_GroupTag_less_open1_TweakDBID_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: Map < root :: RED4ext :: TweakDBID , root :: RED4ext :: TweakDB_GroupTag :: Type > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::std::less>() - 1usize];
["Align of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::std::less>() - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: HashMap_open0_CName_ptr_FlatValue__bindgen_ty_id_506487_open1_CName_void_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: TweakDB_FlatValue > > () - 48usize] ;
["Align of template specialization: HashMap_open0_CName_ptr_FlatValue__bindgen_ty_id_506487_open1_CName_void_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: HashMap < root :: RED4ext :: CName , * mut root :: RED4ext :: TweakDB_FlatValue > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_CString_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 16usize];
["Align of template specialization: DynArray_open0_CString_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::CString>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::std::less>() - 1usize];
["Align of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::std::less>() - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: size_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 16usize] ;
["Align of template specialization: DynArray_open0_Handle_open1_IScriptable_close1_close0"] [:: std :: mem :: align_of :: < root :: RED4ext :: DynArray < root :: RED4ext :: Handle < root :: RED4ext :: IScriptable > > > () - 8usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::size_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 16usize];
["Align of template specialization: Handle_open0_IScriptable_close0"]
[::std::mem::align_of::<root::RED4ext::Handle<root::RED4ext::IScriptable>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 16usize];
["Align of template specialization: DynArray_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::RED4ext::DynArray<root::RED4ext::TweakDBID>>() - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::size_of::<root::std::less>() - 1usize];
["Align of template specialization: less_open0_TweakDBID_close0"]
[::std::mem::align_of::<root::std::less>() - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of template specialization: ResourceAsyncReference_open0_CResource_close0"]
[::std::mem::size_of::<root::RED4ext::ResourceAsyncReference>() - 8usize];
["Align of template specialization: ResourceAsyncReference_open0_CResource_close0"]
[::std::mem::align_of::<root::RED4ext::ResourceAsyncReference>() - 8usize];
};
}